/* Arranged according to https://tonejs.github.io/docs/ */

/* BASE CLASS */
var Tone = function() {};
Tone.Offline = function() {}
Tone.connectSeries = function() {}
Tone.dbToGain = function() {}
Tone.defaultArg = function() {}
Tone.defaults = function() {}
Tone.equalPowerScale = function() {}
Tone.extend = function() {}
Tone.gainToDb = function() {}
Tone.immediate = function() {}
Tone.intervalToFrequencyRatio = function() {}
Tone.isArray = function() {}
Tone.isBoolean = function() {}
Tone.isDefined = function() {}
Tone.isFunction = function() {}
Tone.isNote = function() {}
Tone.isNumber = function() {}
Tone.isObject = function() {}
Tone.isString = function() {}
Tone.isUndef = function() {}
Tone.loaded = function() {}
Tone.now = function() {}
Tone.start = function() {}
Tone.prototype.context = {}
Tone.prototype.receive = function() {}
Tone.prototype.send = function() {}
Tone.prototype.toFrequency = function() {}
Tone.prototype.toSeconds = function() {}
Tone.prototype.toTicks = function() {}

/* EFFECT */
Tone.Chorus = function() {}
Tone.Chorus.prototype.delayTime = {}
Tone.Chorus.prototype.depth = {}
Tone.Chorus.prototype.frequency = {}
Tone.Chorus.prototype.spread = {}
Tone.Chorus.prototype.type = {}
Tone.Chorus.prototype.channelCount = {}
Tone.Chorus.prototype.channelCountMode = {}
Tone.Chorus.prototype.channelInterpretation = {}
Tone.Chorus.prototype.context = {}
Tone.Chorus.prototype.numberOfInputs = {}
Tone.Chorus.prototype.numberOfOutputs = {}
Tone.Chorus.prototype.wet = {}
Tone.Chorus.prototype.dispose = function() {}
Tone.Chorus.prototype.chain = function() {}
Tone.Chorus.prototype.connect = function() {}
Tone.Chorus.prototype.disconnect = function() {}
Tone.Chorus.prototype.fan = function() {}
Tone.Chorus.prototype.toMaster = function() {}

Tone.AutoPanner = function() {}
Tone.AutoPanner.prototype.depth = {}
Tone.AutoPanner.prototype.frequency = {}
Tone.AutoPanner.prototype.channelCount = {}
Tone.AutoPanner.prototype.channelCountMode = {}
Tone.AutoPanner.prototype.channelInterpretation = {}
Tone.AutoPanner.prototype.context = {}
Tone.AutoPanner.prototype.numberOfInputs = {}
Tone.AutoPanner.prototype.numberOfOutputs = {}
Tone.AutoPanner.prototype.wet = {}
Tone.AutoPanner.prototype.dispose = function() {}
Tone.AutoPanner.prototype.start = function() {}
Tone.AutoPanner.prototype.stop = function() {}
Tone.AutoPanner.prototype.sync = function() {}
Tone.AutoPanner.prototype.unsync = function() {}
Tone.AutoPanner.prototype.chain = function() {}
Tone.AutoPanner.prototype.connect = function() {}
Tone.AutoPanner.prototype.disconnect = function() {}
Tone.AutoPanner.prototype.fan = function() {}
Tone.AutoPanner.prototype.toMaster = function() {}

Tone.AutoWah = function() {}
Tone.AutoWah.prototype.Q = {}
Tone.AutoWah.prototype.baseFrequency = {}
Tone.AutoWah.prototype.gain = {}
Tone.AutoWah.prototype.octaves = {}
Tone.AutoWah.prototype.sensitivity = {}
Tone.AutoWah.prototype.channelCount = {}
Tone.AutoWah.prototype.channelCountMode = {}
Tone.AutoWah.prototype.channelInterpretation = {}
Tone.AutoWah.prototype.context = {}
Tone.AutoWah.prototype.numberOfInputs = {}
Tone.AutoWah.prototype.numberOfOutputs = {}
Tone.AutoWah.prototype.wet = {}
Tone.AutoWah.prototype.dispose = function() {}
Tone.AutoWah.prototype.chain = function() {}
Tone.AutoWah.prototype.connect = function() {}
Tone.AutoWah.prototype.disconnect = function() {}
Tone.AutoWah.prototype.fan = function() {}
Tone.AutoWah.prototype.toMaster = function() {}

Tone.PitchShift = function() {}
Tone.PitchShift.prototype.delayTime = {}
Tone.PitchShift.prototype.pitch = {}
Tone.PitchShift.prototype.windowSize = {}
Tone.PitchShift.prototype.channelCount = {}
Tone.PitchShift.prototype.channelCountMode = {}
Tone.PitchShift.prototype.channelInterpretation = {}
Tone.PitchShift.prototype.context = {}
Tone.PitchShift.prototype.numberOfInputs = {}
Tone.PitchShift.prototype.numberOfOutputs = {}
Tone.PitchShift.prototype.wet = {}
Tone.PitchShift.prototype.feedback = {}
Tone.PitchShift.prototype.dispose = function() {}
Tone.PitchShift.prototype.chain = function() {}
Tone.PitchShift.prototype.connect = function() {}
Tone.PitchShift.prototype.disconnect = function() {}
Tone.PitchShift.prototype.fan = function() {}
Tone.PitchShift.prototype.toMaster = function() {}

Tone.StereoWidener = function() {}
Tone.StereoWidener.prototype.width = {}
Tone.StereoWidener.prototype.channelCount = {}
Tone.StereoWidener.prototype.channelCountMode = {}
Tone.StereoWidener.prototype.channelInterpretation = {}
Tone.StereoWidener.prototype.context = {}
Tone.StereoWidener.prototype.numberOfInputs = {}
Tone.StereoWidener.prototype.numberOfOutputs = {}
Tone.StereoWidener.prototype.wet = {}
Tone.StereoWidener.prototype.dispose = function() {}
Tone.StereoWidener.prototype.chain = function() {}
Tone.StereoWidener.prototype.connect = function() {}
Tone.StereoWidener.prototype.disconnect = function() {}
Tone.StereoWidener.prototype.fan = function() {}
Tone.StereoWidener.prototype.toMaster = function() {}

Tone.Tremolo = function() {}
Tone.Tremolo.prototype.depth = {}
Tone.Tremolo.prototype.frequency = {}
Tone.Tremolo.prototype.spread = {}
Tone.Tremolo.prototype.type = {}
Tone.Tremolo.prototype.channelCount = {}
Tone.Tremolo.prototype.channelCountMode = {}
Tone.Tremolo.prototype.channelInterpretation = {}
Tone.Tremolo.prototype.context = {}
Tone.Tremolo.prototype.numberOfInputs = {}
Tone.Tremolo.prototype.numberOfOutputs = {}
Tone.Tremolo.prototype.wet = {}
Tone.Tremolo.prototype.dispose = function() {}
Tone.Tremolo.prototype.start = function() {}
Tone.Tremolo.prototype.stop = function() {}
Tone.Tremolo.prototype.sync = function() {}
Tone.Tremolo.prototype.unsync = function() {}
Tone.Tremolo.prototype.chain = function() {}
Tone.Tremolo.prototype.connect = function() {}
Tone.Tremolo.prototype.disconnect = function() {}
Tone.Tremolo.prototype.fan = function() {}
Tone.Tremolo.prototype.toMaster = function() {}

Tone.Effect = function() {}
Tone.Effect.prototype.wet = {}
Tone.Effect.prototype.channelCount = {}
Tone.Effect.prototype.channelCountMode = {}
Tone.Effect.prototype.channelInterpretation = {}
Tone.Effect.prototype.context = {}
Tone.Effect.prototype.numberOfInputs = {}
Tone.Effect.prototype.numberOfOutputs = {}
Tone.Effect.prototype.dispose = function() {}
Tone.Effect.prototype.chain = function() {}
Tone.Effect.prototype.connect = function() {}
Tone.Effect.prototype.disconnect = function() {}
Tone.Effect.prototype.fan = function() {}
Tone.Effect.prototype.toMaster = function() {}

Tone.PingPongDelay = function() {}
Tone.PingPongDelay.prototype.delayTime = {}
Tone.PingPongDelay.prototype.channelCount = {}
Tone.PingPongDelay.prototype.channelCountMode = {}
Tone.PingPongDelay.prototype.channelInterpretation = {}
Tone.PingPongDelay.prototype.context = {}
Tone.PingPongDelay.prototype.numberOfInputs = {}
Tone.PingPongDelay.prototype.numberOfOutputs = {}
Tone.PingPongDelay.prototype.wet = {}
Tone.PingPongDelay.prototype.feedback = {}
Tone.PingPongDelay.prototype.dispose = function() {}
Tone.PingPongDelay.prototype.chain = function() {}
Tone.PingPongDelay.prototype.connect = function() {}
Tone.PingPongDelay.prototype.disconnect = function() {}
Tone.PingPongDelay.prototype.fan = function() {}
Tone.PingPongDelay.prototype.toMaster = function() {}

Tone.MidSideEffect = function() {}
Tone.MidSideEffect.prototype.channelCount = {}
Tone.MidSideEffect.prototype.channelCountMode = {}
Tone.MidSideEffect.prototype.channelInterpretation = {}
Tone.MidSideEffect.prototype.context = {}
Tone.MidSideEffect.prototype.numberOfInputs = {}
Tone.MidSideEffect.prototype.numberOfOutputs = {}
Tone.MidSideEffect.prototype.wet = {}
Tone.MidSideEffect.prototype.dispose = function() {}
Tone.MidSideEffect.prototype.chain = function() {}
Tone.MidSideEffect.prototype.connect = function() {}
Tone.MidSideEffect.prototype.disconnect = function() {}
Tone.MidSideEffect.prototype.fan = function() {}
Tone.MidSideEffect.prototype.toMaster = function() {}

Tone.Convolver = function() {}
Tone.Convolver.prototype.buffer = {}
Tone.Convolver.prototype.normalize = {}
Tone.Convolver.prototype.channelCount = {}
Tone.Convolver.prototype.channelCountMode = {}
Tone.Convolver.prototype.channelInterpretation = {}
Tone.Convolver.prototype.context = {}
Tone.Convolver.prototype.numberOfInputs = {}
Tone.Convolver.prototype.numberOfOutputs = {}
Tone.Convolver.prototype.wet = {}
Tone.Convolver.prototype.dispose = function() {}
Tone.Convolver.prototype.load = function() {}
Tone.Convolver.prototype.chain = function() {}
Tone.Convolver.prototype.connect = function() {}
Tone.Convolver.prototype.disconnect = function() {}
Tone.Convolver.prototype.fan = function() {}
Tone.Convolver.prototype.toMaster = function() {}

Tone.StereoFeedbackEffect = function() {}
Tone.StereoFeedbackEffect.prototype.feedback = {}
Tone.StereoFeedbackEffect.prototype.channelCount = {}
Tone.StereoFeedbackEffect.prototype.channelCountMode = {}
Tone.StereoFeedbackEffect.prototype.channelInterpretation = {}
Tone.StereoFeedbackEffect.prototype.context = {}
Tone.StereoFeedbackEffect.prototype.numberOfInputs = {}
Tone.StereoFeedbackEffect.prototype.numberOfOutputs = {}
Tone.StereoFeedbackEffect.prototype.wet = {}
Tone.StereoFeedbackEffect.prototype.dispose = function() {}
Tone.StereoFeedbackEffect.prototype.chain = function() {}
Tone.StereoFeedbackEffect.prototype.connect = function() {}
Tone.StereoFeedbackEffect.prototype.disconnect = function() {}
Tone.StereoFeedbackEffect.prototype.fan = function() {}
Tone.StereoFeedbackEffect.prototype.toMaster = function() {}

Tone.Chebyshev = function() {}
Tone.Chebyshev.prototype.order = {}
Tone.Chebyshev.prototype.oversample = {}
Tone.Chebyshev.prototype.channelCount = {}
Tone.Chebyshev.prototype.channelCountMode = {}
Tone.Chebyshev.prototype.channelInterpretation = {}
Tone.Chebyshev.prototype.context = {}
Tone.Chebyshev.prototype.numberOfInputs = {}
Tone.Chebyshev.prototype.numberOfOutputs = {}
Tone.Chebyshev.prototype.wet = {}
Tone.Chebyshev.prototype.dispose = function() {}
Tone.Chebyshev.prototype.chain = function() {}
Tone.Chebyshev.prototype.connect = function() {}
Tone.Chebyshev.prototype.disconnect = function() {}
Tone.Chebyshev.prototype.fan = function() {}
Tone.Chebyshev.prototype.toMaster = function() {}

Tone.StereoEffect = function() {}
Tone.StereoEffect.prototype.wet = {}
Tone.StereoEffect.prototype.channelCount = {}
Tone.StereoEffect.prototype.channelCountMode = {}
Tone.StereoEffect.prototype.channelInterpretation = {}
Tone.StereoEffect.prototype.context = {}
Tone.StereoEffect.prototype.numberOfInputs = {}
Tone.StereoEffect.prototype.numberOfOutputs = {}
Tone.StereoEffect.prototype.dispose = function() {}
Tone.StereoEffect.prototype.chain = function() {}
Tone.StereoEffect.prototype.connect = function() {}
Tone.StereoEffect.prototype.disconnect = function() {}
Tone.StereoEffect.prototype.fan = function() {}
Tone.StereoEffect.prototype.toMaster = function() {}

Tone.Vibrato = function() {}
Tone.Vibrato.prototype.depth = {}
Tone.Vibrato.prototype.frequency = {}
Tone.Vibrato.prototype.type = {}
Tone.Vibrato.prototype.channelCount = {}
Tone.Vibrato.prototype.channelCountMode = {}
Tone.Vibrato.prototype.channelInterpretation = {}
Tone.Vibrato.prototype.context = {}
Tone.Vibrato.prototype.numberOfInputs = {}
Tone.Vibrato.prototype.numberOfOutputs = {}
Tone.Vibrato.prototype.wet = {}
Tone.Vibrato.prototype.dispose = function() {}
Tone.Vibrato.prototype.chain = function() {}
Tone.Vibrato.prototype.connect = function() {}
Tone.Vibrato.prototype.disconnect = function() {}
Tone.Vibrato.prototype.fan = function() {}
Tone.Vibrato.prototype.toMaster = function() {}

Tone.BitCrusher = function() {}
Tone.BitCrusher.prototype.bits = {}
Tone.BitCrusher.prototype.channelCount = {}
Tone.BitCrusher.prototype.channelCountMode = {}
Tone.BitCrusher.prototype.channelInterpretation = {}
Tone.BitCrusher.prototype.context = {}
Tone.BitCrusher.prototype.numberOfInputs = {}
Tone.BitCrusher.prototype.numberOfOutputs = {}
Tone.BitCrusher.prototype.wet = {}
Tone.BitCrusher.prototype.dispose = function() {}
Tone.BitCrusher.prototype.chain = function() {}
Tone.BitCrusher.prototype.connect = function() {}
Tone.BitCrusher.prototype.disconnect = function() {}
Tone.BitCrusher.prototype.fan = function() {}
Tone.BitCrusher.prototype.toMaster = function() {}

Tone.StereoXFeedbackEffect = function() {}
Tone.StereoXFeedbackEffect.prototype.feedback = {}
Tone.StereoXFeedbackEffect.prototype.channelCount = {}
Tone.StereoXFeedbackEffect.prototype.channelCountMode = {}
Tone.StereoXFeedbackEffect.prototype.channelInterpretation = {}
Tone.StereoXFeedbackEffect.prototype.context = {}
Tone.StereoXFeedbackEffect.prototype.numberOfInputs = {}
Tone.StereoXFeedbackEffect.prototype.numberOfOutputs = {}
Tone.StereoXFeedbackEffect.prototype.wet = {}
Tone.StereoXFeedbackEffect.prototype.dispose = function() {}
Tone.StereoXFeedbackEffect.prototype.chain = function() {}
Tone.StereoXFeedbackEffect.prototype.connect = function() {}
Tone.StereoXFeedbackEffect.prototype.disconnect = function() {}
Tone.StereoXFeedbackEffect.prototype.fan = function() {}
Tone.StereoXFeedbackEffect.prototype.toMaster = function() {}

Tone.FeedbackEffect = function() {}
Tone.FeedbackEffect.prototype.feedback = {}
Tone.FeedbackEffect.prototype.channelCount = {}
Tone.FeedbackEffect.prototype.channelCountMode = {}
Tone.FeedbackEffect.prototype.channelInterpretation = {}
Tone.FeedbackEffect.prototype.context = {}
Tone.FeedbackEffect.prototype.numberOfInputs = {}
Tone.FeedbackEffect.prototype.numberOfOutputs = {}
Tone.FeedbackEffect.prototype.wet = {}
Tone.FeedbackEffect.prototype.dispose = function() {}
Tone.FeedbackEffect.prototype.chain = function() {}
Tone.FeedbackEffect.prototype.connect = function() {}
Tone.FeedbackEffect.prototype.disconnect = function() {}
Tone.FeedbackEffect.prototype.fan = function() {}
Tone.FeedbackEffect.prototype.toMaster = function() {}

Tone.Reverb = function() {}
Tone.Reverb.prototype.decay = {}
Tone.Reverb.prototype.preDelay = {}
Tone.Reverb.prototype.channelCount = {}
Tone.Reverb.prototype.channelCountMode = {}
Tone.Reverb.prototype.channelInterpretation = {}
Tone.Reverb.prototype.context = {}
Tone.Reverb.prototype.numberOfInputs = {}
Tone.Reverb.prototype.numberOfOutputs = {}
Tone.Reverb.prototype.buffer = {}
Tone.Reverb.prototype.normalize = {}
Tone.Reverb.prototype.wet = {}
Tone.Reverb.prototype.dispose = function() {}
Tone.Reverb.prototype.generate = function() {}
Tone.Reverb.prototype.chain = function() {}
Tone.Reverb.prototype.connect = function() {}
Tone.Reverb.prototype.disconnect = function() {}
Tone.Reverb.prototype.fan = function() {}
Tone.Reverb.prototype.toMaster = function() {}
Tone.Reverb.prototype.load = function() {}

Tone.Distortion = function() {}
Tone.Distortion.prototype.distortion = {}
Tone.Distortion.prototype.oversample = {}
Tone.Distortion.prototype.channelCount = {}
Tone.Distortion.prototype.channelCountMode = {}
Tone.Distortion.prototype.channelInterpretation = {}
Tone.Distortion.prototype.context = {}
Tone.Distortion.prototype.numberOfInputs = {}
Tone.Distortion.prototype.numberOfOutputs = {}
Tone.Distortion.prototype.wet = {}
Tone.Distortion.prototype.dispose = function() {}
Tone.Distortion.prototype.chain = function() {}
Tone.Distortion.prototype.connect = function() {}
Tone.Distortion.prototype.disconnect = function() {}
Tone.Distortion.prototype.fan = function() {}
Tone.Distortion.prototype.toMaster = function() {}

Tone.JCReverb = function() {}
Tone.JCReverb.prototype.roomSize = {}
Tone.JCReverb.prototype.channelCount = {}
Tone.JCReverb.prototype.channelCountMode = {}
Tone.JCReverb.prototype.channelInterpretation = {}
Tone.JCReverb.prototype.context = {}
Tone.JCReverb.prototype.numberOfInputs = {}
Tone.JCReverb.prototype.numberOfOutputs = {}
Tone.JCReverb.prototype.wet = {}
Tone.JCReverb.prototype.dispose = function() {}
Tone.JCReverb.prototype.chain = function() {}
Tone.JCReverb.prototype.connect = function() {}
Tone.JCReverb.prototype.disconnect = function() {}
Tone.JCReverb.prototype.fan = function() {}
Tone.JCReverb.prototype.toMaster = function() {}

Tone.Freeverb = function() {}
Tone.Freeverb.prototype.dampening = {}
Tone.Freeverb.prototype.roomSize = {}
Tone.Freeverb.prototype.channelCount = {}
Tone.Freeverb.prototype.channelCountMode = {}
Tone.Freeverb.prototype.channelInterpretation = {}
Tone.Freeverb.prototype.context = {}
Tone.Freeverb.prototype.numberOfInputs = {}
Tone.Freeverb.prototype.numberOfOutputs = {}
Tone.Freeverb.prototype.wet = {}
Tone.Freeverb.prototype.dispose = function() {}
Tone.Freeverb.prototype.chain = function() {}
Tone.Freeverb.prototype.connect = function() {}
Tone.Freeverb.prototype.disconnect = function() {}
Tone.Freeverb.prototype.fan = function() {}
Tone.Freeverb.prototype.toMaster = function() {}

Tone.AutoFilter = function() {}
Tone.AutoFilter.prototype.baseFrequency = {}
Tone.AutoFilter.prototype.depth = {}
Tone.AutoFilter.prototype.filter = {}
Tone.AutoFilter.prototype.frequency = {}
Tone.AutoFilter.prototype.octaves = {}
Tone.AutoFilter.prototype.type = {}
Tone.AutoFilter.prototype.channelCount = {}
Tone.AutoFilter.prototype.channelCountMode = {}
Tone.AutoFilter.prototype.channelInterpretation = {}
Tone.AutoFilter.prototype.context = {}
Tone.AutoFilter.prototype.numberOfInputs = {}
Tone.AutoFilter.prototype.numberOfOutputs = {}
Tone.AutoFilter.prototype.wet = {}
Tone.AutoFilter.prototype.dispose = function() {}
Tone.AutoFilter.prototype.start = function() {}
Tone.AutoFilter.prototype.stop = function() {}
Tone.AutoFilter.prototype.sync = function() {}
Tone.AutoFilter.prototype.unsync = function() {}
Tone.AutoFilter.prototype.chain = function() {}
Tone.AutoFilter.prototype.connect = function() {}
Tone.AutoFilter.prototype.disconnect = function() {}
Tone.AutoFilter.prototype.fan = function() {}
Tone.AutoFilter.prototype.toMaster = function() {}

Tone.FeedbackDelay = function() {}
Tone.FeedbackDelay.prototype.delayTime = {}
Tone.FeedbackDelay.prototype.channelCount = {}
Tone.FeedbackDelay.prototype.channelCountMode = {}
Tone.FeedbackDelay.prototype.channelInterpretation = {}
Tone.FeedbackDelay.prototype.context = {}
Tone.FeedbackDelay.prototype.numberOfInputs = {}
Tone.FeedbackDelay.prototype.numberOfOutputs = {}
Tone.FeedbackDelay.prototype.wet = {}
Tone.FeedbackDelay.prototype.feedback = {}
Tone.FeedbackDelay.prototype.dispose = function() {}
Tone.FeedbackDelay.prototype.chain = function() {}
Tone.FeedbackDelay.prototype.connect = function() {}
Tone.FeedbackDelay.prototype.disconnect = function() {}
Tone.FeedbackDelay.prototype.fan = function() {}
Tone.FeedbackDelay.prototype.toMaster = function() {}

Tone.Phaser = function() {}
Tone.Phaser.prototype.Q = {}
Tone.Phaser.prototype.baseFrequency = {}
Tone.Phaser.prototype.frequency = {}
Tone.Phaser.prototype.octaves = {}
Tone.Phaser.prototype.channelCount = {}
Tone.Phaser.prototype.channelCountMode = {}
Tone.Phaser.prototype.channelInterpretation = {}
Tone.Phaser.prototype.context = {}
Tone.Phaser.prototype.numberOfInputs = {}
Tone.Phaser.prototype.numberOfOutputs = {}
Tone.Phaser.prototype.wet = {}
Tone.Phaser.prototype.dispose = function() {}
Tone.Phaser.prototype.chain = function() {}
Tone.Phaser.prototype.connect = function() {}
Tone.Phaser.prototype.disconnect = function() {}
Tone.Phaser.prototype.fan = function() {}
Tone.Phaser.prototype.toMaster = function() {}

/* CONTROL */
Tone.CtrlPattern = function() {}
Tone.CtrlPattern.prototype.index = {}
Tone.CtrlPattern.prototype.type = {}
Tone.CtrlPattern.prototype.value = {}
Tone.CtrlPattern.prototype.values = {}
Tone.CtrlPattern.prototype.dispose = function() {}
Tone.CtrlPattern.prototype.next = function() {}

Tone.CtrlMarkov = function() {}
Tone.CtrlMarkov.prototype.value = {}
Tone.CtrlMarkov.prototype.values = {}
Tone.CtrlMarkov.prototype.dispose = function() {}
Tone.CtrlMarkov.prototype.next = function() {}

Tone.CtrlRandom = function() {};
Tone.CtrlRandom.prototype.integer = {}
Tone.CtrlRandom.prototype.max = {}
Tone.CtrlRandom.prototype.min = {}
Tone.CtrlRandom.prototype.value = {}

Tone.CtrlInterpolate = function() {}
Tone.CtrlInterpolate.prototype.index = {}
Tone.CtrlInterpolate.prototype.value = {}
Tone.CtrlInterpolate.prototype.values = {}
Tone.CtrlInterpolate.prototype.dispose = function() {}

/*EVENT*/
Tone.Sequence = function() {}
Tone.Sequence.prototype.subdivision = {}
Tone.Sequence.prototype.callback = {}
Tone.Sequence.prototype.mute = {}
Tone.Sequence.prototype.progress = {}
Tone.Sequence.prototype.state = {}
Tone.Sequence.prototype.length = {}
Tone.Sequence.prototype.loop = {}
Tone.Sequence.prototype.loopEnd = {}
Tone.Sequence.prototype.loopStart = {}
Tone.Sequence.prototype.playbackRate = {}
Tone.Sequence.prototype.probability = {}
Tone.Sequence.prototype.add = function() {}
Tone.Sequence.prototype.at = function() {}
Tone.Sequence.prototype.dispose = function() {}
Tone.Sequence.prototype.remove = function() {}
Tone.Sequence.prototype.cancel = function() {}
Tone.Sequence.prototype.removeAll = function() {}
Tone.Sequence.prototype.start = function() {}
Tone.Sequence.prototype.stop = function() {}

Tone.Event = function() {};
Tone.Event.prototype.callback = {}
Tone.Event.prototype.loop = {}
Tone.Event.prototype.loopEnd = {}
Tone.Event.prototype.loopStart = {}
Tone.Event.prototype.mute = {}
Tone.Event.prototype.playbackRate = {}
Tone.Event.prototype.probability = {}
Tone.Event.prototype.progress = {}
Tone.Event.prototype.state = {}
Tone.Event.prototype.cancel = function() {}
Tone.Event.prototype.dispose = function() {}
Tone.Event.prototype.start = function() {}
Tone.Event.prototype.stop = function() {}

Tone.Part = function() {};
Tone.Part.prototype.length = {}
Tone.Part.prototype.loop = {}
Tone.Part.prototype.loopEnd = {}
Tone.Part.prototype.loopStart = {}
Tone.Part.prototype.playbackRate = {}
Tone.Part.prototype.probability = {}
Tone.Part.prototype.callback = {}
Tone.Part.prototype.mute = {}
Tone.Part.prototype.progress = {}
Tone.Part.prototype.state = {}
Tone.Part.prototype.add = function() {} 
Tone.Part.prototype.at = function() {}
Tone.Part.prototype.cancel = function() {}
Tone.Part.prototype.dispose = function() {}
Tone.Part.prototype.remove = function() {}
Tone.Part.prototype.removeAll = function() {}
Tone.Part.prototype.start = function() {}
Tone.Part.prototype.stop = function() {}

Tone.Pattern = function() {};
Tone.Pattern.prototype.index = {}
Tone.Pattern.prototype.pattern = {}
Tone.Pattern.prototype.value = {}
Tone.Pattern.prototype.values = {}
Tone.Pattern.prototype.callback = {}
Tone.Pattern.prototype.humanize = {}
Tone.Pattern.prototype.interval = {}
Tone.Pattern.prototype.iterations = {}
Tone.Pattern.prototype.mute = {}
Tone.Pattern.prototype.playbackRate = {}
Tone.Pattern.prototype.probability = {}
Tone.Pattern.prototype.progress = {}
Tone.Pattern.prototype.state = {}
Tone.Pattern.prototype.dispose = function() {}
Tone.Pattern.prototype.cancel = function() {}
Tone.Pattern.prototype.start = function() {}
Tone.Pattern.prototype.stop = function() {}

Tone.Loop = function() {};
Tone.Loop.prototype.callback = {}
Tone.Loop.prototype.humanize = {}
Tone.Loop.prototype.interval = {}
Tone.Loop.prototype.iterations = {}
Tone.Loop.prototype.mute = {}
Tone.Loop.prototype.playbackRate = {}
Tone.Loop.prototype.probability = {}
Tone.Loop.prototype.progress = {}
Tone.Loop.prototype.state = {}
Tone.Loop.prototype.cancel = function() {}
Tone.Loop.prototype.dispose = function() {}
Tone.Loop.prototype.start = function() {}
Tone.Loop.prototype.stop = function() {}

/* INSTRUMENT */
Tone.Instrument = function() {}
Tone.Instrument.prototype.volume = {}
Tone.Instrument.prototype.channelCount = {}
Tone.Instrument.prototype.channelCountMode = {}
Tone.Instrument.prototype.channelInterpretation = {}
Tone.Instrument.prototype.context = {}
Tone.Instrument.prototype.numberOfInputs = {}
Tone.Instrument.prototype.numberOfOutputs = {}
Tone.Instrument.prototype.dispose = function() {}
Tone.Instrument.prototype.sync = function() {}
Tone.Instrument.prototype.triggerAttackRelease = function() {}
Tone.Instrument.prototype.unsync = function() {}
Tone.Instrument.prototype.chain = function() {}
Tone.Instrument.prototype.connect = function() {}
Tone.Instrument.prototype.disconnect = function() {}
Tone.Instrument.prototype.fan = function() {}
Tone.Instrument.prototype.toMaster = function() {}

Tone.NoiseSynth = function() {}
Tone.NoiseSynth.prototype.envelope = {}
Tone.NoiseSynth.prototype.noise = {}
Tone.NoiseSynth.prototype.channelCount = {}
Tone.NoiseSynth.prototype.channelCountMode = {}
Tone.NoiseSynth.prototype.channelInterpretation = {}
Tone.NoiseSynth.prototype.context = {}
Tone.NoiseSynth.prototype.numberOfInputs = {}
Tone.NoiseSynth.prototype.numberOfOutputs = {}
Tone.NoiseSynth.prototype.volume = {}
Tone.NoiseSynth.prototype.dispose = function() {}
Tone.NoiseSynth.prototype.sync = function() {}
Tone.NoiseSynth.prototype.triggerAttack = function() {}
Tone.NoiseSynth.prototype.triggerAttackRelease = function() {}
Tone.NoiseSynth.prototype.triggerRelease = function() {}
Tone.NoiseSynth.prototype.chain = function() {}
Tone.NoiseSynth.prototype.connect = function() {}
Tone.NoiseSynth.prototype.disconnect = function() {}
Tone.NoiseSynth.prototype.fan = function() {}
Tone.NoiseSynth.prototype.toMaster = function() {}
Tone.NoiseSynth.prototype.unsync = function() {}

Tone.Synth = function() {}
Tone.Synth.prototype.detune = {}
Tone.Synth.prototype.envelope = {}
Tone.Synth.prototype.frequency = {}
Tone.Synth.prototype.oscillator = {}
Tone.Synth.prototype.channelCount = {}
Tone.Synth.prototype.channelCountMode = {}
Tone.Synth.prototype.channelInterpretation = {}
Tone.Synth.prototype.context = {}
Tone.Synth.prototype.numberOfInputs = {}
Tone.Synth.prototype.numberOfOutputs = {}
Tone.Synth.prototype.volume = {}
Tone.Synth.prototype.portamento = {}
Tone.Synth.prototype.dispose = function() {}
Tone.Synth.prototype.chain = function() {}
Tone.Synth.prototype.connect = function() {}
Tone.Synth.prototype.disconnect = function() {}
Tone.Synth.prototype.fan = function() {}
Tone.Synth.prototype.toMaster = function() {}
Tone.Synth.prototype.sync = function() {}
Tone.Synth.prototype.triggerAttackRelease = function() {}
Tone.Synth.prototype.unsync = function() {}
Tone.Synth.prototype.getLevelAtTime = function() {}
Tone.Synth.prototype.setNote = function() {}
Tone.Synth.prototype.triggerAttack = function() {}
Tone.Synth.prototype.triggerRelease = function() {}

Tone.AMSynth = function() {}
Tone.AMSynth.prototype.detune = {}
Tone.AMSynth.prototype.envelope = {}
Tone.AMSynth.prototype.frequency = {}
Tone.AMSynth.prototype.harmonicity = {}
Tone.AMSynth.prototype.modulation = {}
Tone.AMSynth.prototype.modulationEnvelope = {}
Tone.AMSynth.prototype.oscillator = {}
Tone.AMSynth.prototype.channelCount = {}
Tone.AMSynth.prototype.channelCountMode = {}
Tone.AMSynth.prototype.channelInterpretation = {}
Tone.AMSynth.prototype.context = {}
Tone.AMSynth.prototype.numberOfInputs = {}
Tone.AMSynth.prototype.numberOfOutputs = {}
Tone.AMSynth.prototype.volume = {}
Tone.AMSynth.prototype.portamento = {}
Tone.AMSynth.prototype.dispose = function() {}
Tone.AMSynth.prototype.chain = function() {}
Tone.AMSynth.prototype.connect = function() {}
Tone.AMSynth.prototype.disconnect = function() {}
Tone.AMSynth.prototype.fan = function() {}
Tone.AMSynth.prototype.toMaster = function() {}
Tone.AMSynth.prototype.sync = function() {}
Tone.AMSynth.prototype.triggerAttackRelease = function() {}
Tone.AMSynth.prototype.unsync = function() {}
Tone.AMSynth.prototype.getLevelAtTime = function() {}
Tone.AMSynth.prototype.setNote = function() {}
Tone.AMSynth.prototype.triggerAttack = function() {}
Tone.AMSynth.prototype.triggerRelease = function() {}

Tone.DuoSynth = function() {}
Tone.DuoSynth.prototype.frequency = {}
Tone.DuoSynth.prototype.harmonicity = {}
Tone.DuoSynth.prototype.vibratoAmount = {}
Tone.DuoSynth.prototype.vibratoRate = {}
Tone.DuoSynth.prototype.voice0 = {}
Tone.DuoSynth.prototype.voice1 = {}
Tone.DuoSynth.prototype.channelCount = {}
Tone.DuoSynth.prototype.channelCountMode = {}
Tone.DuoSynth.prototype.channelInterpretation = {}
Tone.DuoSynth.prototype.context = {}
Tone.DuoSynth.prototype.numberOfInputs = {}
Tone.DuoSynth.prototype.numberOfOutputs = {}
Tone.DuoSynth.prototype.volume = {}
Tone.DuoSynth.prototype.portamento = {}
Tone.DuoSynth.prototype.dispose = function() {}
Tone.DuoSynth.prototype.getLevelAtTime = function() {}
Tone.DuoSynth.prototype.chain = function() {}
Tone.DuoSynth.prototype.connect = function() {}
Tone.DuoSynth.prototype.disconnect = function() {}
Tone.DuoSynth.prototype.fan = function() {}
Tone.DuoSynth.prototype.toMaster = function() {}
Tone.DuoSynth.prototype.sync = function() {}
Tone.DuoSynth.prototype.triggerAttackRelease = function() {}
Tone.DuoSynth.prototype.unsync = function() {}
Tone.DuoSynth.prototype.setNote = function() {}
Tone.DuoSynth.prototype.triggerAttack = function() {}
Tone.DuoSynth.prototype.triggerRelease = function() {}

Tone.Sampler = function() {}
Tone.Sampler.prototype.attack = {}
Tone.Sampler.prototype.curve = {}
Tone.Sampler.prototype.loaded = {}
Tone.Sampler.prototype.release = {}
Tone.Sampler.prototype.channelCount = {}
Tone.Sampler.prototype.channelCountMode = {}
Tone.Sampler.prototype.channelInterpretation = {}
Tone.Sampler.prototype.context = {}
Tone.Sampler.prototype.numberOfInputs = {}
Tone.Sampler.prototype.numberOfOutputs = {}
Tone.Sampler.prototype.volume = {}
Tone.Sampler.prototype.add = function() {}
Tone.Sampler.prototype.dispose = function() {}
Tone.Sampler.prototype.releaseAll = function() {}
Tone.Sampler.prototype.sync = function() {}
Tone.Sampler.prototype.triggerAttack = function() {}
Tone.Sampler.prototype.triggerAttackRelease = function() {}
Tone.Sampler.prototype.triggerRelease = function() {}
Tone.Sampler.prototype.chain = function() {}
Tone.Sampler.prototype.connect = function() {}
Tone.Sampler.prototype.disconnect = function() {}
Tone.Sampler.prototype.fan = function() {}
Tone.Sampler.prototype.toMaster = function() {}
Tone.Sampler.prototype.unsync = function() {}

Tone.FMSynth = function() {}
Tone.FMSynth.prototype.detune = {}
Tone.FMSynth.prototype.envelope = {}
Tone.FMSynth.prototype.frequency = {}
Tone.FMSynth.prototype.harmonicity = {}
Tone.FMSynth.prototype.modulation = {}
Tone.FMSynth.prototype.modulationEnvelope = {}
Tone.FMSynth.prototype.modulationIndex = {}
Tone.FMSynth.prototype.oscillator = {}
Tone.FMSynth.prototype.channelCount = {}
Tone.FMSynth.prototype.channelCountMode = {}
Tone.FMSynth.prototype.channelInterpretation = {}
Tone.FMSynth.prototype.context = {}
Tone.FMSynth.prototype.numberOfInputs = {}
Tone.FMSynth.prototype.numberOfOutputs = {}
Tone.FMSynth.prototype.volume = {}
Tone.FMSynth.prototype.portamento = {}
Tone.FMSynth.prototype.dispose = function() {}
Tone.FMSynth.prototype.chain = function() {}
Tone.FMSynth.prototype.connect = function() {}
Tone.FMSynth.prototype.disconnect = function() {}
Tone.FMSynth.prototype.fan = function() {}
Tone.FMSynth.prototype.toMaster = function() {}
Tone.FMSynth.prototype.sync = function() {}
Tone.FMSynth.prototype.triggerAttackRelease = function() {}
Tone.FMSynth.prototype.unsync = function() {}
Tone.FMSynth.prototype.getLevelAtTime = function() {}
Tone.FMSynth.prototype.setNote = function() {}
Tone.FMSynth.prototype.triggerAttack = function() {}
Tone.FMSynth.prototype.triggerRelease = function() {}

Tone.MonoSynth = function() {}
Tone.MonoSynth.prototype.detune = {}
Tone.MonoSynth.prototype.envelope = {}
Tone.MonoSynth.prototype.filter = {}
Tone.MonoSynth.prototype.filterEnvelope = {}
Tone.MonoSynth.prototype.frequency = {}
Tone.MonoSynth.prototype.oscillator = {}
Tone.MonoSynth.prototype.channelCount = {}
Tone.MonoSynth.prototype.channelCountMode = {}
Tone.MonoSynth.prototype.channelInterpretation = {}
Tone.MonoSynth.prototype.context = {}
Tone.MonoSynth.prototype.numberOfInputs = {}
Tone.MonoSynth.prototype.numberOfOutputs = {}
Tone.MonoSynth.prototype.volume = {}
Tone.MonoSynth.prototype.portamento = {}
Tone.MonoSynth.prototype.dispose = function() {}
Tone.MonoSynth.prototype.chain = function() {}
Tone.MonoSynth.prototype.connect = function() {}
Tone.MonoSynth.prototype.disconnect = function() {}
Tone.MonoSynth.prototype.fan = function() {}
Tone.MonoSynth.prototype.toMaster = function() {}
Tone.MonoSynth.prototype.sync = function() {}
Tone.MonoSynth.prototype.triggerAttackRelease = function() {}
Tone.MonoSynth.prototype.unsync = function() {}
Tone.MonoSynth.prototype.getLevelAtTime = function() {}
Tone.MonoSynth.prototype.setNote = function() {}
Tone.MonoSynth.prototype.triggerAttack = function() {}
Tone.MonoSynth.prototype.triggerRelease = function() {}

Tone.PluckSynth = function() {}
Tone.PluckSynth.prototype.attackNoise = {}
Tone.PluckSynth.prototype.dampening = {}
Tone.PluckSynth.prototype.resonance = {}
Tone.PluckSynth.prototype.channelCount = {}
Tone.PluckSynth.prototype.channelCountMode = {}
Tone.PluckSynth.prototype.channelInterpretation = {}
Tone.PluckSynth.prototype.context = {}
Tone.PluckSynth.prototype.numberOfInputs = {}
Tone.PluckSynth.prototype.numberOfOutputs = {}
Tone.PluckSynth.prototype.volume = {}
Tone.PluckSynth.prototype.dispose = function() {}
Tone.PluckSynth.prototype.triggerAttack = function() {}
Tone.PluckSynth.prototype.chain = function() {}
Tone.PluckSynth.prototype.connect = function() {}
Tone.PluckSynth.prototype.disconnect = function() {}
Tone.PluckSynth.prototype.fan = function() {}
Tone.PluckSynth.prototype.toMaster = function() {}
Tone.PluckSynth.prototype.sync = function() {}
Tone.PluckSynth.prototype.unsync = function() {}

Tone.MetalSynth = function() {}
Tone.MetalSynth.prototype.envelope = {}
Tone.MetalSynth.prototype.frequency = {}
Tone.MetalSynth.prototype.harmonicity = {}
Tone.MetalSynth.prototype.modulationIndex = {}
Tone.MetalSynth.prototype.octaves = {}
Tone.MetalSynth.prototype.resonance = {}
Tone.MetalSynth.prototype.channelCount = {}
Tone.MetalSynth.prototype.channelCountMode = {}
Tone.MetalSynth.prototype.channelInterpretation = {}
Tone.MetalSynth.prototype.context = {}
Tone.MetalSynth.prototype.numberOfInputs = {}
Tone.MetalSynth.prototype.numberOfOutputs = {}
Tone.MetalSynth.prototype.volume = {}
Tone.MetalSynth.prototype.dispose = function() {}
Tone.MetalSynth.prototype.sync = function() {}
Tone.MetalSynth.prototype.triggerAttack = function() {}
Tone.MetalSynth.prototype.triggerAttackRelease = function() {}
Tone.MetalSynth.prototype.triggerRelease = function() {}
Tone.MetalSynth.prototype.chain = function() {}
Tone.MetalSynth.prototype.connect = function() {}
Tone.MetalSynth.prototype.disconnect = function() {}
Tone.MetalSynth.prototype.fan = function() {}
Tone.MetalSynth.prototype.toMaster = function() {}
Tone.MetalSynth.prototype.unsync = function() {}

Tone.PolySynth = function() {}
Tone.PolySynth.prototype.detune = {}
Tone.PolySynth.prototype.voices = {}
Tone.PolySynth.prototype.channelCount = {}
Tone.PolySynth.prototype.channelCountMode = {}
Tone.PolySynth.prototype.channelInterpretation = {}
Tone.PolySynth.prototype.context = {}
Tone.PolySynth.prototype.numberOfInputs = {}
Tone.PolySynth.prototype.numberOfOutputs = {}
Tone.PolySynth.prototype.volume = {}
Tone.PolySynth.prototype.dispose = function() {}
Tone.PolySynth.prototype.get = function() {}
Tone.PolySynth.prototype.releaseAll = function() {}
Tone.PolySynth.prototype.set = function() {}
Tone.PolySynth.prototype.sync = function() {}
Tone.PolySynth.prototype.triggerAttack = function() {}
Tone.PolySynth.prototype.triggerAttackRelease = function() {}
Tone.PolySynth.prototype.triggerRelease = function() {}
Tone.PolySynth.prototype.chain = function() {}
Tone.PolySynth.prototype.connect = function() {}
Tone.PolySynth.prototype.disconnect = function() {}
Tone.PolySynth.prototype.fan = function() {}
Tone.PolySynth.prototype.toMaster = function() {}
Tone.PolySynth.prototype.unsync = function() {}

Tone.Monophonic = function() {}
Tone.Monophonic.prototype.portamento = {}
Tone.Monophonic.prototype.channelCount = {}
Tone.Monophonic.prototype.channelCountMode = {}
Tone.Monophonic.prototype.channelInterpretation = {}
Tone.Monophonic.prototype.context = {}
Tone.Monophonic.prototype.numberOfInputs = {}
Tone.Monophonic.prototype.numberOfOutputs = {}
Tone.Monophonic.prototype.volume = {}
Tone.Monophonic.prototype.getLevelAtTime = function() {}
Tone.Monophonic.prototype.setNote = function() {}
Tone.Monophonic.prototype.triggerAttack = function() {}
Tone.Monophonic.prototype.triggerRelease = function() {}
Tone.Monophonic.prototype.chain = function() {}
Tone.Monophonic.prototype.connect = function() {}
Tone.Monophonic.prototype.disconnect = function() {}
Tone.Monophonic.prototype.fan = function() {}
Tone.Monophonic.prototype.toMaster = function() {}
Tone.Monophonic.prototype.dispose = function() {}
Tone.Monophonic.prototype.sync = function() {}
Tone.Monophonic.prototype.triggerAttackRelease = function() {}
Tone.Monophonic.prototype.unsync = function() {}

Tone.MembraneSynth = function() {}
Tone.MembraneSynth.prototype.envelope = {}
Tone.MembraneSynth.prototype.octaves = {}
Tone.MembraneSynth.prototype.oscillator = {}
Tone.MembraneSynth.prototype.pitchDecay = {}
Tone.MembraneSynth.prototype.channelCount = {}
Tone.MembraneSynth.prototype.channelCountMode = {}
Tone.MembraneSynth.prototype.channelInterpretation = {}
Tone.MembraneSynth.prototype.context = {}
Tone.MembraneSynth.prototype.numberOfInputs = {}
Tone.MembraneSynth.prototype.numberOfOutputs = {}
Tone.MembraneSynth.prototype.volume = {}
Tone.MembraneSynth.prototype.dispose = function() {}
Tone.MembraneSynth.prototype.triggerAttack = function() {}
Tone.MembraneSynth.prototype.triggerRelease = function() {}
Tone.MembraneSynth.prototype.chain = function() {}
Tone.MembraneSynth.prototype.connect = function() {}
Tone.MembraneSynth.prototype.disconnect = function() {}
Tone.MembraneSynth.prototype.fan = function() {}
Tone.MembraneSynth.prototype.toMaster = function() {}
Tone.MembraneSynth.prototype.sync = function() {}
Tone.MembraneSynth.prototype.triggerAttackRelease = function() {}
Tone.MembraneSynth.prototype.unsync = function() {}

/* TYPE */
Tone.Midi = function() {}
Tone.Midi.prototype.toFrequency = function() {}
Tone.Midi.prototype.toMidi = function() {}
Tone.Midi.prototype.transpose = function() {}
Tone.Midi.prototype.harmonize = function() {}
Tone.Midi.prototype.toNote = function() {}
Tone.Midi.prototype.toSeconds = function() {}
Tone.Midi.prototype.toTicks = function() {}
Tone.Midi.prototype.dispose = function() {}
Tone.Midi.prototype.toMilliseconds = function() {}
Tone.Midi.prototype.toSamples = function() {}
Tone.Midi.prototype.valueOf = function() {}

Tone.Frequency = function() {}
Tone.Frequency.ftom = function() {}
Tone.Frequency.mtof = function() {}
Tone.Frequency.prototype.harmonize = function() {}
Tone.Frequency.prototype.toFrequency = function() {}
Tone.Frequency.prototype.toMidi = function() {}
Tone.Frequency.prototype.toNote = function() {}
Tone.Frequency.prototype.toSeconds = function() {}
Tone.Frequency.prototype.toTicks = function() {}
Tone.Frequency.prototype.transpose = function() {}
Tone.Frequency.prototype.dispose = function() {}
Tone.Frequency.prototype.toMilliseconds = function() {}
Tone.Frequency.prototype.toSamples = function() {}
Tone.Frequency.prototype.valueOf = function() {}

Tone.TimeBase = function() {}
Tone.TimeBase.prototype.dispose = function() {}
Tone.TimeBase.prototype.toFrequency = function() {}
Tone.TimeBase.prototype.toMilliseconds = function() {}
Tone.TimeBase.prototype.toSamples = function() {}
Tone.TimeBase.prototype.toSeconds = function() {}
Tone.TimeBase.prototype.valueOf = function() {}

Tone.TransportTime = function() {}
Tone.TransportTime.prototype.quantize = function() {}
Tone.TransportTime.prototype.toBarsBeatsSixteenths = function() {}
Tone.TransportTime.prototype.toMidi = function() {}
Tone.TransportTime.prototype.toNotation = function() {}
Tone.TransportTime.prototype.toSeconds = function() {}
Tone.TransportTime.prototype.toTicks = function() {}
Tone.TransportTime.prototype.dispose = function() {}
Tone.TransportTime.prototype.toFrequency = function() {}
Tone.TransportTime.prototype.toMilliseconds = function() {}
Tone.TransportTime.prototype.toSamples = function() {}
Tone.TransportTime.prototype.valueOf = function() {}

Tone.Ticks = function() {}
Tone.Ticks.prototype.toSeconds = function() {}
Tone.Ticks.prototype.toTicks = function() {}
Tone.Ticks.prototype.quantize = function() {}
Tone.Ticks.prototype.toBarsBeatsSixteenths = function() {}
Tone.Ticks.prototype.toMidi = function() {}
Tone.Ticks.prototype.toNotation = function() {}
Tone.Ticks.prototype.dispose = function() {}
Tone.Ticks.prototype.toFrequency = function() {}
Tone.Ticks.prototype.toMilliseconds = function() {}
Tone.Ticks.prototype.toSamples = function() {}
Tone.Ticks.prototype.valueOf = function() {}

Tone.Time = function() {}
Tone.Time.prototype.quantize = function() {}
Tone.Time.prototype.toBarsBeatsSixteenths = function() {}
Tone.Time.prototype.toMidi = function() {}
Tone.Time.prototype.toNotation = function() {}
Tone.Time.prototype.toSeconds = function() {}
Tone.Time.prototype.toTicks = function() {}
Tone.Time.prototype.dispose = function() {}
Tone.Time.prototype.toFrequency = function() {}
Tone.Time.prototype.toMilliseconds = function() {}
Tone.Time.prototype.toSamples = function() {}
Tone.Time.prototype.valueOf = function() {}

/* SOURCE */
Tone.TickSource = function() {}
Tone.TickSource.prototype.frequency = {}
Tone.TickSource.prototype.seconds = {}
Tone.TickSource.prototype.state = {}
Tone.TickSource.prototype.ticks = {}
Tone.TickSource.prototype.cancel = function() {}
Tone.TickSource.prototype.dispose = function() {}
Tone.TickSource.prototype.forEachTickBetween = function() {}
Tone.TickSource.prototype.getSecondsAtTime = function() {}
Tone.TickSource.prototype.getStateAtTime = function() {}
Tone.TickSource.prototype.getTicksAtTime = function() {}
Tone.TickSource.prototype.getTimeOfTick = function() {}
Tone.TickSource.prototype.pause = function() {}
Tone.TickSource.prototype.setTicksAtTime = function() {}
Tone.TickSource.prototype.start = function() {}
Tone.TickSource.prototype.stop = function() {}

Tone.FatOscillator = function() {}
Tone.FatOscillator.prototype.baseType = {}
Tone.FatOscillator.prototype.count = {}
Tone.FatOscillator.prototype.detune = {}
Tone.FatOscillator.prototype.frequency = {}
Tone.FatOscillator.prototype.partialCount = {}
Tone.FatOscillator.prototype.partials = {}
Tone.FatOscillator.prototype.phase = {}
Tone.FatOscillator.prototype.spread = {}
Tone.FatOscillator.prototype.type = {}
Tone.FatOscillator.prototype.channelCount = {}
Tone.FatOscillator.prototype.channelCountMode = {}
Tone.FatOscillator.prototype.channelInterpretation = {}
Tone.FatOscillator.prototype.context = {}
Tone.FatOscillator.prototype.numberOfInputs = {}
Tone.FatOscillator.prototype.numberOfOutputs = {}
Tone.FatOscillator.prototype.fadeIn = {}
Tone.FatOscillator.prototype.fadeOut = {}
Tone.FatOscillator.prototype.mute = {}
Tone.FatOscillator.prototype.state = {}
Tone.FatOscillator.prototype.volume = {}
Tone.FatOscillator.prototype.dispose = function() {}
Tone.FatOscillator.prototype.chain = function() {}
Tone.FatOscillator.prototype.connect = function() {}
Tone.FatOscillator.prototype.disconnect = function() {}
Tone.FatOscillator.prototype.fan = function() {}
Tone.FatOscillator.prototype.toMaster = function() {}
Tone.FatOscillator.prototype.start = function() {}
Tone.FatOscillator.prototype.stop = function() {}
Tone.FatOscillator.prototype.sync = function() {}
Tone.FatOscillator.prototype.unsync = function() {}

Tone.Players = function() {}
Tone.Players.prototype.loaded = {}
Tone.Players.prototype.state = {}
Tone.Players.prototype.volume = {}
Tone.Players.prototype.channelCount = {}
Tone.Players.prototype.channelCountMode = {}
Tone.Players.prototype.channelInterpretation = {}
Tone.Players.prototype.context = {}
Tone.Players.prototype.numberOfInputs = {}
Tone.Players.prototype.numberOfOutputs = {}
Tone.Players.prototype.add = function() {}
Tone.Players.prototype.dispose = function() {}
Tone.Players.prototype.get = function() {}
Tone.Players.prototype.has = function() {}
Tone.Players.prototype.stopAll = function() {}
Tone.Players.prototype.chain = function() {}
Tone.Players.prototype.connect = function() {}
Tone.Players.prototype.disconnect = function() {}
Tone.Players.prototype.fan = function() {}
Tone.Players.prototype.toMaster = function() {}

Tone.OmniOscillator = function() {}
Tone.OmniOscillator.prototype.baseType = {}
Tone.OmniOscillator.prototype.count = {}
Tone.OmniOscillator.prototype.detune = {}
Tone.OmniOscillator.prototype.frequency = {}
Tone.OmniOscillator.prototype.harmonicity = {}
Tone.OmniOscillator.prototype.modulationFrequency = {}
Tone.OmniOscillator.prototype.modulationType = {}
Tone.OmniOscillator.prototype.partialCount = {}
Tone.OmniOscillator.prototype.partials = {}
Tone.OmniOscillator.prototype.phase = {}
Tone.OmniOscillator.prototype.sourceType = {}
Tone.OmniOscillator.prototype.spread = {}
Tone.OmniOscillator.prototype.type = {}
Tone.OmniOscillator.prototype.width = {}
Tone.OmniOscillator.prototype.channelCount = {}
Tone.OmniOscillator.prototype.channelCountMode = {}
Tone.OmniOscillator.prototype.channelInterpretation = {}
Tone.OmniOscillator.prototype.context = {}
Tone.OmniOscillator.prototype.numberOfInputs = {}
Tone.OmniOscillator.prototype.numberOfOutputs = {}
Tone.OmniOscillator.prototype.fadeIn = {}
Tone.OmniOscillator.prototype.fadeOut = {}
Tone.OmniOscillator.prototype.mute = {}
Tone.OmniOscillator.prototype.state = {}
Tone.OmniOscillator.prototype.volume = {}
Tone.OmniOscillator.prototype.dispose = function() {}
Tone.OmniOscillator.prototype.get = function() {}
Tone.OmniOscillator.prototype.restart = function() {}
Tone.OmniOscillator.prototype.set = function() {}
Tone.OmniOscillator.prototype.chain = function() {}
Tone.OmniOscillator.prototype.connect = function() {}
Tone.OmniOscillator.prototype.disconnect = function() {}
Tone.OmniOscillator.prototype.fan = function() {}
Tone.OmniOscillator.prototype.toMaster = function() {}
Tone.OmniOscillator.prototype.start = function() {}
Tone.OmniOscillator.prototype.stop = function() {}
Tone.OmniOscillator.prototype.sync = function() {}
Tone.OmniOscillator.prototype.unsync = function() {}

Tone.PWMOscillator = function() {}
Tone.PWMOscillator.prototype.baseType = {}
Tone.PWMOscillator.prototype.detune = {}
Tone.PWMOscillator.prototype.frequency = {}
Tone.PWMOscillator.prototype.modulationFrequency = {}
Tone.PWMOscillator.prototype.phase = {}
Tone.PWMOscillator.prototype.type = {}
Tone.PWMOscillator.prototype.channelCount = {}
Tone.PWMOscillator.prototype.channelCountMode = {}
Tone.PWMOscillator.prototype.channelInterpretation = {}
Tone.PWMOscillator.prototype.context = {}
Tone.PWMOscillator.prototype.numberOfInputs = {}
Tone.PWMOscillator.prototype.numberOfOutputs = {}
Tone.PWMOscillator.prototype.fadeIn = {}
Tone.PWMOscillator.prototype.fadeOut = {}
Tone.PWMOscillator.prototype.mute = {}
Tone.PWMOscillator.prototype.state = {}
Tone.PWMOscillator.prototype.volume = {}
Tone.PWMOscillator.prototype.dispose = function() {}
Tone.PWMOscillator.prototype.chain = function() {}
Tone.PWMOscillator.prototype.connect = function() {}
Tone.PWMOscillator.prototype.disconnect = function() {}
Tone.PWMOscillator.prototype.fan = function() {}
Tone.PWMOscillator.prototype.toMaster = function() {}
Tone.PWMOscillator.prototype.start = function() {}
Tone.PWMOscillator.prototype.stop = function() {}
Tone.PWMOscillator.prototype.sync = function() {}
Tone.PWMOscillator.prototype.unsync = function() {}

Tone.Player = function() {}
Tone.Player.prototype.autostart = {}
Tone.Player.prototype.buffer = {}
Tone.Player.prototype.fadeIn = {}
Tone.Player.prototype.fadeOut = {}
Tone.Player.prototype.loaded = {}
Tone.Player.prototype.loop = {}
Tone.Player.prototype.loopEnd = {}
Tone.Player.prototype.loopStart = {}
Tone.Player.prototype.playbackRate = {}
Tone.Player.prototype.reverse = {}
Tone.Player.prototype.channelCount = {}
Tone.Player.prototype.channelCountMode = {}
Tone.Player.prototype.channelInterpretation = {}
Tone.Player.prototype.context = {}
Tone.Player.prototype.numberOfInputs = {}
Tone.Player.prototype.numberOfOutputs = {}
Tone.Player.prototype.mute = {}
Tone.Player.prototype.state = {}
Tone.Player.prototype.volume = {}
Tone.Player.prototype.dispose = function() {}
Tone.Player.prototype.load = function() {}
Tone.Player.prototype.restart = function() {}
Tone.Player.prototype.seek = function() {}
Tone.Player.prototype.setLoopPoints = function() {}
Tone.Player.prototype.start = function() {}
Tone.Player.prototype.chain = function() {}
Tone.Player.prototype.connect = function() {}
Tone.Player.prototype.disconnect = function() {}
Tone.Player.prototype.fan = function() {}
Tone.Player.prototype.toMaster = function() {}
Tone.Player.prototype.stop = function() {}
Tone.Player.prototype.sync = function() {}
Tone.Player.prototype.unsync = function() {}

Tone.BufferSource = function() {}
Tone.BufferSource.prototype.buffer = {}
Tone.BufferSource.prototype.curve = {}
Tone.BufferSource.prototype.fadeIn = {}
Tone.BufferSource.prototype.fadeOut = {}
Tone.BufferSource.prototype.loop = {}
Tone.BufferSource.prototype.loopEnd = {}
Tone.BufferSource.prototype.loopStart = {}
Tone.BufferSource.prototype.onended = {}
Tone.BufferSource.prototype.playbackRate = {}
Tone.BufferSource.prototype.state = {}
Tone.BufferSource.prototype.channelCount = {}
Tone.BufferSource.prototype.channelCountMode = {}
Tone.BufferSource.prototype.channelInterpretation = {}
Tone.BufferSource.prototype.context = {}
Tone.BufferSource.prototype.numberOfInputs = {}
Tone.BufferSource.prototype.numberOfOutputs = {}
Tone.BufferSource.prototype.cancelStop = function() {}
Tone.BufferSource.prototype.dispose = function() {}
Tone.BufferSource.prototype.getStateAtTime = function() {}
Tone.BufferSource.prototype.start = function() {}
Tone.BufferSource.prototype.stop = function() {}
Tone.BufferSource.prototype.chain = function() {}
Tone.BufferSource.prototype.connect = function() {}
Tone.BufferSource.prototype.disconnect = function() {}
Tone.BufferSource.prototype.fan = function() {}
Tone.BufferSource.prototype.toMaster = function() {}

Tone.AMOscillator = function() {}
Tone.AMOscillator.prototype.baseType = {}
Tone.AMOscillator.prototype.detune = {}
Tone.AMOscillator.prototype.frequency = {}
Tone.AMOscillator.prototype.harmonicity = {}
Tone.AMOscillator.prototype.modulationType = {}
Tone.AMOscillator.prototype.partialCount = {}
Tone.AMOscillator.prototype.partials = {}
Tone.AMOscillator.prototype.phase = {}
Tone.AMOscillator.prototype.type = {}
Tone.AMOscillator.prototype.channelCount = {}
Tone.AMOscillator.prototype.channelCountMode = {}
Tone.AMOscillator.prototype.channelInterpretation = {}
Tone.AMOscillator.prototype.context = {}
Tone.AMOscillator.prototype.numberOfInputs = {}
Tone.AMOscillator.prototype.numberOfOutputs = {}
Tone.AMOscillator.prototype.fadeIn = {}
Tone.AMOscillator.prototype.fadeOut = {}
Tone.AMOscillator.prototype.mute = {}
Tone.AMOscillator.prototype.state = {}
Tone.AMOscillator.prototype.volume = {}
Tone.AMOscillator.prototype.dispose = function() {}
Tone.AMOscillator.prototype.chain = function() {}
Tone.AMOscillator.prototype.connect = function() {}
Tone.AMOscillator.prototype.disconnect = function() {}
Tone.AMOscillator.prototype.fan = function() {}
Tone.AMOscillator.prototype.toMaster = function() {}
Tone.AMOscillator.prototype.syncFrequency = function() {}
Tone.AMOscillator.prototype.unsyncFrequency = function() {}
Tone.AMOscillator.prototype.start = function() {}
Tone.AMOscillator.prototype.stop = function() {}
Tone.AMOscillator.prototype.sync = function() {}
Tone.AMOscillator.prototype.unsync = function() {}

Tone.OscillatorNode = function() {}
Tone.OscillatorNode.prototype.detune = {}
Tone.OscillatorNode.prototype.frequency = {}
Tone.OscillatorNode.prototype.onended = {}
Tone.OscillatorNode.prototype.state = {}
Tone.OscillatorNode.prototype.type = {}
Tone.OscillatorNode.prototype.channelCount = {}
Tone.OscillatorNode.prototype.channelCountMode = {}
Tone.OscillatorNode.prototype.channelInterpretation = {}
Tone.OscillatorNode.prototype.context = {}
Tone.OscillatorNode.prototype.numberOfInputs = {}
Tone.OscillatorNode.prototype.numberOfOutputs = {}
Tone.OscillatorNode.prototype.cancelStop = function() {}
Tone.OscillatorNode.prototype.dispose = function() {}
Tone.OscillatorNode.prototype.getStateAtTime = function() {}
Tone.OscillatorNode.prototype.setPeriodicWave = function() {}
Tone.OscillatorNode.prototype.start = function() {}
Tone.OscillatorNode.prototype.stop = function() {}
Tone.OscillatorNode.prototype.chain = function() {}
Tone.OscillatorNode.prototype.connect = function() {}
Tone.OscillatorNode.prototype.disconnect = function() {}
Tone.OscillatorNode.prototype.fan = function() {}
Tone.OscillatorNode.prototype.toMaster = function() {}

Tone.UserMedia = function() {}
Tone.UserMedia.enumerateDevices = function() {}
Tone.UserMedia.prototype.deviceId = {}
Tone.UserMedia.prototype.groupId = {}
Tone.UserMedia.prototype.groupId = {}
Tone.UserMedia.prototype.mute = {}
Tone.UserMedia.prototype.state = {}
Tone.UserMedia.prototype.supported = {}
Tone.UserMedia.prototype.volume = {}
Tone.UserMedia.prototype.channelCount = {}
Tone.UserMedia.prototype.channelCountMode = {}
Tone.UserMedia.prototype.channelInterpretation = {}
Tone.UserMedia.prototype.context = {}
Tone.UserMedia.prototype.numberOfInputs = {}
Tone.UserMedia.prototype.numberOfOutputs = {}
Tone.UserMedia.prototype.close = function() {}
Tone.UserMedia.prototype.dispose = function() {}
Tone.UserMedia.prototype.open = function() {}
Tone.UserMedia.prototype.chain = function() {}
Tone.UserMedia.prototype.connect = function() {}
Tone.UserMedia.prototype.disconnect = function() {}
Tone.UserMedia.prototype.fan = function() {}
Tone.UserMedia.prototype.toMaster = function() {}

Tone.GrainPlayer = function() {}
Tone.GrainPlayer.prototype.buffer = {}
Tone.GrainPlayer.prototype.detune = {}
Tone.GrainPlayer.prototype.grainSize = {}
Tone.GrainPlayer.prototype.loaded = {}
Tone.GrainPlayer.prototype.loopEnd = {}
Tone.GrainPlayer.prototype.loopStart = {}
Tone.GrainPlayer.prototype.overlap = {}
Tone.GrainPlayer.prototype.playbackRate = {}
Tone.GrainPlayer.prototype.reverse = {}
Tone.GrainPlayer.prototype.channelCount = {}
Tone.GrainPlayer.prototype.channelCountMode = {}
Tone.GrainPlayer.prototype.channelInterpretation = {}
Tone.GrainPlayer.prototype.context = {}
Tone.GrainPlayer.prototype.numberOfInputs = {}
Tone.GrainPlayer.prototype.numberOfOutputs = {}
Tone.GrainPlayer.prototype.fadeIn = {}
Tone.GrainPlayer.prototype.fadeOut = {}
Tone.GrainPlayer.prototype.mute = {}
Tone.GrainPlayer.prototype.state = {}
Tone.GrainPlayer.prototype.volume = {}
Tone.GrainPlayer.prototype.dispose = function() {}
Tone.GrainPlayer.prototype.start = function() {}
Tone.GrainPlayer.prototype.chain = function() {}
Tone.GrainPlayer.prototype.connect = function() {}
Tone.GrainPlayer.prototype.disconnect = function() {}
Tone.GrainPlayer.prototype.fan = function() {}
Tone.GrainPlayer.prototype.toMaster = function() {}
Tone.GrainPlayer.prototype.stop = function() {}
Tone.GrainPlayer.prototype.sync = function() {}
Tone.GrainPlayer.prototype.unsync = function() {}

Tone.Noise = function() {}
Tone.Noise.prototype._playbackRate = {}
Tone.Noise.prototype.type = {}
Tone.Noise.prototype.channelCount = {}
Tone.Noise.prototype.channelCountMode = {}
Tone.Noise.prototype.channelInterpretation = {}
Tone.Noise.prototype.context = {}
Tone.Noise.prototype.numberOfInputs = {}
Tone.Noise.prototype.numberOfOutputs = {}
Tone.Noise.prototype.fadeIn = {}
Tone.Noise.prototype.fadeOut = {}
Tone.Noise.prototype.mute = {}
Tone.Noise.prototype.state = {}
Tone.Noise.prototype.volume = {}
Tone.Noise.prototype.dispose = function() {}
Tone.Noise.prototype.restart = function() {}
Tone.Noise.prototype.chain = function() {}
Tone.Noise.prototype.connect = function() {}
Tone.Noise.prototype.disconnect = function() {}
Tone.Noise.prototype.fan = function() {}
Tone.Noise.prototype.toMaster = function() {}
Tone.Noise.prototype.start = function() {}
Tone.Noise.prototype.stop = function() {}
Tone.Noise.prototype.sync = function() {}
Tone.Noise.prototype.unsync = function() {}

Tone.Source = function() {}
Tone.Source.prototype.fadeIn = {}
Tone.Source.prototype.fadeOut = {}
Tone.Source.prototype.mute = {}
Tone.Source.prototype.mute = {}
Tone.Source.prototype.state = {}
Tone.Source.prototype.volume = {}
Tone.Source.prototype.channelCount = {}
Tone.Source.prototype.channelCountMode = {}
Tone.Source.prototype.channelInterpretation = {}
Tone.Source.prototype.context = {}
Tone.Source.prototype.numberOfInputs = {}
Tone.Source.prototype.numberOfOutputs = {}
Tone.Source.prototype.dispose = function() {}
Tone.Source.prototype.start = function() {}
Tone.Source.prototype.stop = function() {}
Tone.Source.prototype.sync = function() {}
Tone.Source.prototype.unsync = function() {}
Tone.Source.prototype.chain = function() {}
Tone.Source.prototype.connect = function() {}
Tone.Source.prototype.disconnect = function() {}
Tone.Source.prototype.fan = function() {}
Tone.Source.prototype.toMaster = function() {}

Tone.Oscillator = function() {}
Tone.Oscillator.prototype.baseType = {}
Tone.Oscillator.prototype.detune = {}
Tone.Oscillator.prototype.frequency = {}
Tone.Oscillator.prototype.partialCount = {}
Tone.Oscillator.prototype.partials = {}
Tone.Oscillator.prototype.phase = {}
Tone.Oscillator.prototype.type = {}
Tone.Oscillator.prototype.channelCount = {}
Tone.Oscillator.prototype.channelCountMode = {}
Tone.Oscillator.prototype.channelInterpretation = {}
Tone.Oscillator.prototype.context = {}
Tone.Oscillator.prototype.numberOfInputs = {}
Tone.Oscillator.prototype.numberOfOutputs = {}
Tone.Oscillator.prototype.fadeIn = {}
Tone.Oscillator.prototype.fadeOut = {}
Tone.Oscillator.prototype.mute = {}
Tone.Oscillator.prototype.state = {}
Tone.Oscillator.prototype.volume = {}
Tone.Oscillator.prototype.dispose = function() {}
Tone.Oscillator.prototype.get = function() {}
Tone.Oscillator.prototype.restart = function() {}
Tone.Oscillator.prototype.syncFrequency = function() {}
Tone.Oscillator.prototype.unsyncFrequency = function() {}
Tone.Oscillator.prototype.chain = function() {}
Tone.Oscillator.prototype.connect = function() {}
Tone.Oscillator.prototype.disconnect = function() {}
Tone.Oscillator.prototype.fan = function() {}
Tone.Oscillator.prototype.toMaster = function() {}
Tone.Oscillator.prototype.start = function() {}
Tone.Oscillator.prototype.stop = function() {}
Tone.Oscillator.prototype.sync = function() {}
Tone.Oscillator.prototype.unsync = function() {}

Tone.PulseOscillator = function() {}
Tone.PulseOscillator.prototype.baseType = {}
Tone.PulseOscillator.prototype.detune = {}
Tone.PulseOscillator.prototype.frequency = {}
Tone.PulseOscillator.prototype.phase = {}
Tone.PulseOscillator.prototype.type = {}
Tone.PulseOscillator.prototype.width = {}
Tone.PulseOscillator.prototype.channelCount = {}
Tone.PulseOscillator.prototype.channelCountMode = {}
Tone.PulseOscillator.prototype.channelInterpretation = {}
Tone.PulseOscillator.prototype.context = {}
Tone.PulseOscillator.prototype.numberOfInputs = {}
Tone.PulseOscillator.prototype.numberOfOutputs = {}
Tone.PulseOscillator.prototype.fadeIn = {}
Tone.PulseOscillator.prototype.fadeOut = {}
Tone.PulseOscillator.prototype.mute = {}
Tone.PulseOscillator.prototype.state = {}
Tone.PulseOscillator.prototype.volume = {}
Tone.PulseOscillator.prototype.dispose = function() {}
Tone.PulseOscillator.prototype.chain = function() {}
Tone.PulseOscillator.prototype.connect = function() {}
Tone.PulseOscillator.prototype.disconnect = function() {}
Tone.PulseOscillator.prototype.fan = function() {}
Tone.PulseOscillator.prototype.toMaster = function() {}
Tone.PulseOscillator.prototype.start = function() {}
Tone.PulseOscillator.prototype.stop = function() {}
Tone.PulseOscillator.prototype.sync = function() {}
Tone.PulseOscillator.prototype.unsync = function() {}

Tone.FMOscillator = function() {}
Tone.FMOscillator.prototype.baseType = {}
Tone.FMOscillator.prototype.detune = {}
Tone.FMOscillator.prototype.frequency = {}
Tone.FMOscillator.prototype.harmonicity = {}
Tone.FMOscillator.prototype.modulationIndex = {}
Tone.FMOscillator.prototype.modulationType = {}
Tone.FMOscillator.prototype.partialCount = {}
Tone.FMOscillator.prototype.partials = {}
Tone.FMOscillator.prototype.phase = {}
Tone.FMOscillator.prototype.type = {}
Tone.FMOscillator.prototype.channelCount = {}
Tone.FMOscillator.prototype.channelCountMode = {}
Tone.FMOscillator.prototype.channelInterpretation = {}
Tone.FMOscillator.prototype.context = {}
Tone.FMOscillator.prototype.numberOfInputs = {}
Tone.FMOscillator.prototype.numberOfOutputs = {}
Tone.FMOscillator.prototype.fadeIn = {}
Tone.FMOscillator.prototype.fadeOut = {}
Tone.FMOscillator.prototype.mute = {}
Tone.FMOscillator.prototype.state = {}
Tone.FMOscillator.prototype.volume = {}
Tone.FMOscillator.prototype.dispose = function() {}
Tone.FMOscillator.prototype.chain = function() {}
Tone.FMOscillator.prototype.connect = function() {}
Tone.FMOscillator.prototype.disconnect = function() {}
Tone.FMOscillator.prototype.fan = function() {}
Tone.FMOscillator.prototype.toMaster = function() {}
Tone.FMOscillator.prototype.start = function() {}
Tone.FMOscillator.prototype.stop = function() {}
Tone.FMOscillator.prototype.sync = function() {}
Tone.FMOscillator.prototype.unsync = function() {}

/* COMPONENT */
Tone.Waveform = function() {}
Tone.Waveform.prototype.size = {}
Tone.Waveform.prototype.channelCount = {}
Tone.Waveform.prototype.channelCountMode = {}
Tone.Waveform.prototype.channelInterpretation = {}
Tone.Waveform.prototype.context = {}
Tone.Waveform.prototype.numberOfInputs = {}
Tone.Waveform.prototype.numberOfOutputs = {}
Tone.Waveform.prototype.dispose = function() {}
Tone.Waveform.prototype.getValue = function() {}
Tone.Waveform.prototype.chain = function() {}
Tone.Waveform.prototype.connect = function() {}
Tone.Waveform.prototype.disconnect = function() {}
Tone.Waveform.prototype.fan = function() {}
Tone.Waveform.prototype.toMaster = function() {}

Tone.Compressor = function() {}
Tone.Compressor.prototype.attack = {}
Tone.Compressor.prototype.knee = {}
Tone.Compressor.prototype.ratio = {}
Tone.Compressor.prototype.release = {}
Tone.Compressor.prototype.threshold = {}
Tone.Compressor.prototype.channelCount = {}
Tone.Compressor.prototype.channelCountMode = {}
Tone.Compressor.prototype.channelInterpretation = {}
Tone.Compressor.prototype.context = {}
Tone.Compressor.prototype.numberOfInputs = {}
Tone.Compressor.prototype.numberOfOutputs = {}
Tone.Compressor.prototype.dispose = function() {}
Tone.Compressor.prototype.chain = function() {}
Tone.Compressor.prototype.connect = function() {}
Tone.Compressor.prototype.disconnect = function() {}
Tone.Compressor.prototype.fan = function() {}
Tone.Compressor.prototype.toMaster = function() {}

Tone.MidSideCompressor = function() {}
Tone.MidSideCompressor.prototype.mid = {}
Tone.MidSideCompressor.prototype.side = {}
Tone.MidSideCompressor.prototype.channelCount = {}
Tone.MidSideCompressor.prototype.channelCountMode = {}
Tone.MidSideCompressor.prototype.channelInterpretation = {}
Tone.MidSideCompressor.prototype.context = {}
Tone.MidSideCompressor.prototype.numberOfInputs = {}
Tone.MidSideCompressor.prototype.numberOfOutputs = {}
Tone.MidSideCompressor.prototype.dispose = function() {}
Tone.MidSideCompressor.prototype.chain = function() {}
Tone.MidSideCompressor.prototype.connect = function() {}
Tone.MidSideCompressor.prototype.disconnect = function() {}
Tone.MidSideCompressor.prototype.fan = function() {}
Tone.MidSideCompressor.prototype.toMaster = function() {}

Tone.LowpassCombFilter = function() {}
Tone.LowpassCombFilter.prototype.dampening = {}
Tone.LowpassCombFilter.prototype.delayTime = {}
Tone.LowpassCombFilter.prototype.resonance = {}
Tone.LowpassCombFilter.prototype.channelCount = {}
Tone.LowpassCombFilter.prototype.channelCountMode = {}
Tone.LowpassCombFilter.prototype.channelInterpretation = {}
Tone.LowpassCombFilter.prototype.context = {}
Tone.LowpassCombFilter.prototype.numberOfInputs = {}
Tone.LowpassCombFilter.prototype.numberOfOutputs = {}
Tone.LowpassCombFilter.prototype.dispose = function() {}
Tone.LowpassCombFilter.prototype.chain = function() {}
Tone.LowpassCombFilter.prototype.connect = function() {}
Tone.LowpassCombFilter.prototype.disconnect = function() {}
Tone.LowpassCombFilter.prototype.fan = function() {}
Tone.LowpassCombFilter.prototype.toMaster = function() {}

Tone.PanVol = function() {}
Tone.PanVol.prototype.mute = {}
Tone.PanVol.prototype.pan = {}
Tone.PanVol.prototype.volume = {}
Tone.PanVol.prototype.channelCount = {}
Tone.PanVol.prototype.channelCountMode = {}
Tone.PanVol.prototype.channelInterpretation = {}
Tone.PanVol.prototype.context = {}
Tone.PanVol.prototype.numberOfInputs = {}
Tone.PanVol.prototype.numberOfOutputs = {}
Tone.PanVol.prototype.dispose = function() {}
Tone.PanVol.prototype.chain = function() {}
Tone.PanVol.prototype.connect = function() {}
Tone.PanVol.prototype.disconnect = function() {}
Tone.PanVol.prototype.fan = function() {}
Tone.PanVol.prototype.toMaster = function() {}

Tone.Split = function() {}
Tone.Split.prototype.left = {}
Tone.Split.prototype.right = {}
Tone.Split.prototype.channelCount = {}
Tone.Split.prototype.channelCountMode = {}
Tone.Split.prototype.channelInterpretation = {}
Tone.Split.prototype.context = {}
Tone.Split.prototype.numberOfInputs = {}
Tone.Split.prototype.numberOfOutputs = {}
Tone.Split.prototype.dispose = function() {}
Tone.Split.prototype.chain = function() {}
Tone.Split.prototype.connect = function() {}
Tone.Split.prototype.disconnect = function() {}
Tone.Split.prototype.fan = function() {}
Tone.Split.prototype.toMaster = function() {}

Tone.CrossFade = function() {}
Tone.CrossFade.prototype.a = {}
Tone.CrossFade.prototype.b = {}
Tone.CrossFade.prototype.fade = {}
Tone.CrossFade.prototype.channelCount = {}
Tone.CrossFade.prototype.channelCountMode = {}
Tone.CrossFade.prototype.channelInterpretation = {}
Tone.CrossFade.prototype.context = {}
Tone.CrossFade.prototype.numberOfInputs = {}
Tone.CrossFade.prototype.numberOfOutputs = {}
Tone.CrossFade.prototype.dispose = function() {}
Tone.CrossFade.prototype.chain = function() {}
Tone.CrossFade.prototype.connect = function() {}
Tone.CrossFade.prototype.disconnect = function() {}
Tone.CrossFade.prototype.fan = function() {}
Tone.CrossFade.prototype.toMaster = function() {}

Tone.Envelope = function() {}
Tone.Envelope.prototype.attack = {}
Tone.Envelope.prototype.attackCurve = {}
Tone.Envelope.prototype.decay = {}
Tone.Envelope.prototype.decayCurve = {}
Tone.Envelope.prototype.release = {}
Tone.Envelope.prototype.releaseCurve = {}
Tone.Envelope.prototype.sustain = {}
Tone.Envelope.prototype.value = {}
Tone.Envelope.prototype.channelCount = {}
Tone.Envelope.prototype.channelCountMode = {}
Tone.Envelope.prototype.channelInterpretation = {}
Tone.Envelope.prototype.context = {}
Tone.Envelope.prototype.numberOfInputs = {}
Tone.Envelope.prototype.numberOfOutputs = {}
Tone.Envelope.prototype.cancel = function() {}
Tone.Envelope.prototype.dispose = function() {}
Tone.Envelope.prototype.getValueAtTime = function() {}
Tone.Envelope.prototype.triggerAttack = function() {}
Tone.Envelope.prototype.triggerAttackRelease = function() {}
Tone.Envelope.prototype.triggerRelease = function() {}
Tone.Envelope.prototype.chain = function() {}
Tone.Envelope.prototype.disconnect = function() {}
Tone.Envelope.prototype.fan = function() {}
Tone.Envelope.prototype.toMaster = function() {}

Tone.Gate = function() {}
Tone.Gate.prototype.smoothing = {}
Tone.Gate.prototype.threshold = {}
Tone.Gate.prototype.channelCount = {}
Tone.Gate.prototype.channelCountMode = {}
Tone.Gate.prototype.channelInterpretation = {}
Tone.Gate.prototype.context = {}
Tone.Gate.prototype.numberOfInputs = {}
Tone.Gate.prototype.numberOfOutputs = {}
Tone.Gate.prototype.dispose = function() {}
Tone.Gate.prototype.chain = function() {}
Tone.Gate.prototype.connect = function() {}
Tone.Gate.prototype.disconnect = function() {}
Tone.Gate.prototype.fan = function() {}
Tone.Gate.prototype.toMaster = function() {}

Tone.FFT = function() {}
Tone.FFT.prototype.size = {}
Tone.FFT.prototype.channelCount = {}
Tone.FFT.prototype.channelCountMode = {}
Tone.FFT.prototype.channelInterpretation = {}
Tone.FFT.prototype.context = {}
Tone.FFT.prototype.numberOfInputs = {}
Tone.FFT.prototype.numberOfOutputs = {}
Tone.FFT.prototype.dispose = function() {}
Tone.FFT.prototype.getValue = function() {}
Tone.FFT.prototype.chain = function() {}
Tone.FFT.prototype.connect = function() {}
Tone.FFT.prototype.disconnect = function() {}
Tone.FFT.prototype.fan = function() {}
Tone.FFT.prototype.toMaster = function() {}

Tone.MultibandSplit = function() {}
Tone.MultibandSplit.prototype.Q = {}
Tone.MultibandSplit.prototype.high = {}
Tone.MultibandSplit.prototype.highFrequency = {}
Tone.MultibandSplit.prototype.low = {}
Tone.MultibandSplit.prototype.lowFrequency = {}
Tone.MultibandSplit.prototype.mid = {}
Tone.MultibandSplit.prototype.channelCount = {}
Tone.MultibandSplit.prototype.channelCountMode = {}
Tone.MultibandSplit.prototype.channelInterpretation = {}
Tone.MultibandSplit.prototype.context = {}
Tone.MultibandSplit.prototype.numberOfInputs = {}
Tone.MultibandSplit.prototype.numberOfOutputs = {}
Tone.MultibandSplit.prototype.dispose = function() {}
Tone.MultibandSplit.prototype.chain = function() {}
Tone.MultibandSplit.prototype.connect = function() {}
Tone.MultibandSplit.prototype.disconnect = function() {}
Tone.MultibandSplit.prototype.fan = function() {}
Tone.MultibandSplit.prototype.toMaster = function() {}

Tone.FeedbackCombFilter = function() {}
Tone.FeedbackCombFilter.prototype.delayTime = {}
Tone.FeedbackCombFilter.prototype.resonance = {}
Tone.FeedbackCombFilter.prototype.channelCount = {}
Tone.FeedbackCombFilter.prototype.channelCountMode = {}
Tone.FeedbackCombFilter.prototype.channelInterpretation = {}
Tone.FeedbackCombFilter.prototype.context = {}
Tone.FeedbackCombFilter.prototype.numberOfInputs = {}
Tone.FeedbackCombFilter.prototype.numberOfOutputs = {}
Tone.FeedbackCombFilter.prototype.dispose = function() {}
Tone.FeedbackCombFilter.prototype.chain = function() {}
Tone.FeedbackCombFilter.prototype.connect = function() {}
Tone.FeedbackCombFilter.prototype.disconnect = function() {}
Tone.FeedbackCombFilter.prototype.fan = function() {}
Tone.FeedbackCombFilter.prototype.toMaster = function() {}

Tone.MultibandCompressor = function() {}
Tone.MultibandCompressor.prototype.high = {}
Tone.MultibandCompressor.prototype.highFrequency = {}
Tone.MultibandCompressor.prototype.low = {}
Tone.MultibandCompressor.prototype.lowFrequency = {}
Tone.MultibandCompressor.prototype.mid = {}
Tone.MultibandCompressor.prototype.channelCount = {}
Tone.MultibandCompressor.prototype.channelCountMode = {}
Tone.MultibandCompressor.prototype.channelInterpretation = {}
Tone.MultibandCompressor.prototype.context = {}
Tone.MultibandCompressor.prototype.numberOfInputs = {}
Tone.MultibandCompressor.prototype.numberOfOutputs = {}
Tone.MultibandCompressor.prototype.dispose = function() {}
Tone.MultibandCompressor.prototype.chain = function() {}
Tone.MultibandCompressor.prototype.connect = function() {}
Tone.MultibandCompressor.prototype.disconnect = function() {}
Tone.MultibandCompressor.prototype.fan = function() {}
Tone.MultibandCompressor.prototype.toMaster = function() {}

Tone.Solo = function() {}
Tone.Solo.prototype.input = {}
Tone.Solo.prototype.muted = {}
Tone.Solo.prototype.solo = {}
Tone.Solo.prototype.channelCount = {}
Tone.Solo.prototype.channelCountMode = {}
Tone.Solo.prototype.channelInterpretation = {}
Tone.Solo.prototype.context = {}
Tone.Solo.prototype.numberOfInputs = {}
Tone.Solo.prototype.numberOfOutputs = {}
Tone.Solo.prototype.dispose = function() {}
Tone.Solo.prototype.chain = function() {}
Tone.Solo.prototype.connect = function() {}
Tone.Solo.prototype.disconnect = function() {}
Tone.Solo.prototype.fan = function() {}
Tone.Solo.prototype.toMaster = function() {}

Tone.Channel = function() {}
Tone.Channel.prototype.mute = {}
Tone.Channel.prototype.muted = {}
Tone.Channel.prototype.pan = {}
Tone.Channel.prototype.solo = {}
Tone.Channel.prototype.volume = {}
Tone.Channel.prototype.channelCount = {}
Tone.Channel.prototype.channelCountMode = {}
Tone.Channel.prototype.channelInterpretation = {}
Tone.Channel.prototype.context = {}
Tone.Channel.prototype.numberOfInputs = {}
Tone.Channel.prototype.numberOfOutputs = {}
Tone.Channel.prototype.dispose = function() {}
Tone.Channel.prototype.chain = function() {}
Tone.Channel.prototype.connect = function() {}
Tone.Channel.prototype.disconnect = function() {}
Tone.Channel.prototype.fan = function() {}
Tone.Channel.prototype.toMaster = function() {}

Tone.Limiter = function() {}
Tone.Limiter.prototype.threshold = {}
Tone.Limiter.prototype.channelCount = {}
Tone.Limiter.prototype.channelCountMode = {}
Tone.Limiter.prototype.channelInterpretation = {}
Tone.Limiter.prototype.context = {}
Tone.Limiter.prototype.numberOfInputs = {}
Tone.Limiter.prototype.numberOfOutputs = {}
Tone.Limiter.prototype.dispose = function() {}
Tone.Limiter.prototype.chain = function() {}
Tone.Limiter.prototype.connect = function() {}
Tone.Limiter.prototype.disconnect = function() {}
Tone.Limiter.prototype.fan = function() {}
Tone.Limiter.prototype.toMaster = function() {}

Tone.Mono = function() {}
Tone.Mono.prototype.channelCount = {}
Tone.Mono.prototype.channelCountMode = {}
Tone.Mono.prototype.channelInterpretation = {}
Tone.Mono.prototype.context = {}
Tone.Mono.prototype.numberOfInputs = {}
Tone.Mono.prototype.numberOfOutputs = {}
Tone.Mono.prototype.dispose = function() {}
Tone.Mono.prototype.chain = function() {}
Tone.Mono.prototype.connect = function() {}
Tone.Mono.prototype.disconnect = function() {}
Tone.Mono.prototype.fan = function() {}
Tone.Mono.prototype.toMaster = function() {}

Tone.Meter = function() {}
Tone.Meter.prototype.smoothing = {}
Tone.Meter.prototype.channelCount = {}
Tone.Meter.prototype.channelCountMode = {}
Tone.Meter.prototype.channelInterpretation = {}
Tone.Meter.prototype.context = {}
Tone.Meter.prototype.numberOfInputs = {}
Tone.Meter.prototype.numberOfOutputs = {}
Tone.Meter.prototype.dispose = function() {}
Tone.Meter.prototype.getLevel = function() {}
Tone.Meter.prototype.getValue = function() {}
Tone.Meter.prototype.chain = function() {}
Tone.Meter.prototype.connect = function() {}
Tone.Meter.prototype.disconnect = function() {}
Tone.Meter.prototype.fan = function() {}
Tone.Meter.prototype.toMaster = function() {}

Tone.EQ3 = function() {}
Tone.EQ3.prototype.Q = {}
Tone.EQ3.prototype.high = {}
Tone.EQ3.prototype.highFrequency = {}
Tone.EQ3.prototype.low = {}
Tone.EQ3.prototype.lowFrequency = {}
Tone.EQ3.prototype.mid = {}
Tone.EQ3.prototype.channelCount = {}
Tone.EQ3.prototype.channelCountMode = {}
Tone.EQ3.prototype.channelInterpretation = {}
Tone.EQ3.prototype.context = {}
Tone.EQ3.prototype.numberOfInputs = {}
Tone.EQ3.prototype.numberOfOutputs = {}
Tone.EQ3.prototype.dispose = function() {}
Tone.EQ3.prototype.chain = function() {}
Tone.EQ3.prototype.connect = function() {}
Tone.EQ3.prototype.disconnect = function() {}
Tone.EQ3.prototype.fan = function() {}
Tone.EQ3.prototype.toMaster = function() {}

Tone.LFO = function() {}
Tone.LFO.prototype.amplitude = {}
Tone.LFO.prototype.frequency = {}
Tone.LFO.prototype.max = {}
Tone.LFO.prototype.min = {}
Tone.LFO.prototype.mute = {}
Tone.LFO.prototype.phase = {}
Tone.LFO.prototype.state = {}
Tone.LFO.prototype.type = {}
Tone.LFO.prototype.units = {}
Tone.LFO.prototype.channelCount = {}
Tone.LFO.prototype.channelCountMode = {}
Tone.LFO.prototype.channelInterpretation = {}
Tone.LFO.prototype.context = {}
Tone.LFO.prototype.numberOfInputs = {}
Tone.LFO.prototype.numberOfOutputs = {}
Tone.LFO.prototype.dispose = function() {}
Tone.LFO.prototype.start = function() {}
Tone.LFO.prototype.stop = function() {}
Tone.LFO.prototype.sync = function() {}
Tone.LFO.prototype.unsync = function() {}
Tone.LFO.prototype.chain = function() {}
Tone.LFO.prototype.disconnect = function() {}
Tone.LFO.prototype.fan = function() {}
Tone.LFO.prototype.toMaster = function() {}

Tone.Panner = function() {}
Tone.Panner.prototype.pan = {}
Tone.Panner.prototype.channelCount = {}
Tone.Panner.prototype.channelCountMode = {}
Tone.Panner.prototype.channelInterpretation = {}
Tone.Panner.prototype.context = {}
Tone.Panner.prototype.numberOfInputs = {}
Tone.Panner.prototype.numberOfOutputs = {}
Tone.Panner.prototype.dispose = function() {}
Tone.Panner.prototype.chain = function() {}
Tone.Panner.prototype.connect = function() {}
Tone.Panner.prototype.disconnect = function() {}
Tone.Panner.prototype.fan = function() {}
Tone.Panner.prototype.toMaster = function() {}

Tone.FrequencyEnvelope = function() {}
Tone.FrequencyEnvelope.prototype.baseFrequency = {}
Tone.FrequencyEnvelope.prototype.exponent = {}
Tone.FrequencyEnvelope.prototype.octaves = {}
Tone.FrequencyEnvelope.prototype.channelCount = {}
Tone.FrequencyEnvelope.prototype.channelCountMode = {}
Tone.FrequencyEnvelope.prototype.channelInterpretation = {}
Tone.FrequencyEnvelope.prototype.context = {}
Tone.FrequencyEnvelope.prototype.numberOfInputs = {}
Tone.FrequencyEnvelope.prototype.numberOfOutputs = {}
Tone.FrequencyEnvelope.prototype.attack = {}
Tone.FrequencyEnvelope.prototype.attackCurve = {}
Tone.FrequencyEnvelope.prototype.decay = {}
Tone.FrequencyEnvelope.prototype.decayCurve = {}
Tone.FrequencyEnvelope.prototype.release = {}
Tone.FrequencyEnvelope.prototype.releaseCurve = {}
Tone.FrequencyEnvelope.prototype.sustain = {}
Tone.FrequencyEnvelope.prototype.value = {}
Tone.FrequencyEnvelope.prototype.dispose = function() {}
Tone.FrequencyEnvelope.prototype.chain = function() {}
Tone.FrequencyEnvelope.prototype.disconnect = function() {}
Tone.FrequencyEnvelope.prototype.fan = function() {}
Tone.FrequencyEnvelope.prototype.toMaster = function() {}
Tone.FrequencyEnvelope.prototype.cancel = function() {}
Tone.FrequencyEnvelope.prototype.getValueAtTime = function() {}
Tone.FrequencyEnvelope.prototype.triggerAttack = function() {}
Tone.FrequencyEnvelope.prototype.triggerAttackRelease = function() {}
Tone.FrequencyEnvelope.prototype.triggerRelease = function() {}

Tone.ScaledEnvelope = function() {}
Tone.ScaledEnvelope.prototype.exponent = {}
Tone.ScaledEnvelope.prototype.max = {}
Tone.ScaledEnvelope.prototype.min = {}
Tone.ScaledEnvelope.prototype.channelCount = {}
Tone.ScaledEnvelope.prototype.channelCountMode = {}
Tone.ScaledEnvelope.prototype.channelInterpretation = {}
Tone.ScaledEnvelope.prototype.context = {}
Tone.ScaledEnvelope.prototype.numberOfInputs = {}
Tone.ScaledEnvelope.prototype.numberOfOutputs = {}
Tone.ScaledEnvelope.prototype.attack = {}
Tone.ScaledEnvelope.prototype.attackCurve = {}
Tone.ScaledEnvelope.prototype.decay = {}
Tone.ScaledEnvelope.prototype.decayCurve = {}
Tone.ScaledEnvelope.prototype.release = {}
Tone.ScaledEnvelope.prototype.releaseCurve = {}
Tone.ScaledEnvelope.prototype.sustain = {}
Tone.ScaledEnvelope.prototype.value = {}
Tone.ScaledEnvelope.prototype.dispose = function() {}
Tone.ScaledEnvelope.prototype.chain = function() {}
Tone.ScaledEnvelope.prototype.disconnect = function() {}
Tone.ScaledEnvelope.prototype.fan = function() {}
Tone.ScaledEnvelope.prototype.toMaster = function() {}
Tone.ScaledEnvelope.prototype.cancel = function() {}
Tone.ScaledEnvelope.prototype.getValueAtTime = function() {}
Tone.ScaledEnvelope.prototype.triggerAttack = function() {}
Tone.ScaledEnvelope.prototype.triggerAttackRelease = function() {}
Tone.ScaledEnvelope.prototype.triggerRelease = function() {}

Tone.Analyser = function() {}
Tone.Analyser.prototype.size = {}
Tone.Analyser.prototype.smoothing = {}
Tone.Analyser.prototype.type = {}
Tone.Analyser.prototype.channelCount = {}
Tone.Analyser.prototype.channelCountMode = {}
Tone.Analyser.prototype.channelInterpretation = {}
Tone.Analyser.prototype.context = {}
Tone.Analyser.prototype.numberOfInputs = {}
Tone.Analyser.prototype.numberOfOutputs = {}
Tone.Analyser.prototype.dispose = function() {}
Tone.Analyser.prototype.getValue = function() {}
Tone.Analyser.prototype.chain = function() {}
Tone.Analyser.prototype.connect = function() {}
Tone.Analyser.prototype.disconnect = function() {}
Tone.Analyser.prototype.fan = function() {}
Tone.Analyser.prototype.toMaster = function() {}

Tone.Follower = function() {}
Tone.Follower.prototype.smoothing = {}
Tone.Follower.prototype.channelCount = {}
Tone.Follower.prototype.channelCountMode = {}
Tone.Follower.prototype.channelInterpretation = {}
Tone.Follower.prototype.context = {}
Tone.Follower.prototype.numberOfInputs = {}
Tone.Follower.prototype.numberOfOutputs = {}
Tone.Follower.prototype.connect = function() {}
Tone.Follower.prototype.dispose = function() {}
Tone.Follower.prototype.chain = function() {}
Tone.Follower.prototype.disconnect = function() {}
Tone.Follower.prototype.fan = function() {}
Tone.Follower.prototype.toMaster = function() {}

Tone.AmplitudeEnvelope = function() {}
Tone.AmplitudeEnvelope.prototype.channelCount = {}
Tone.AmplitudeEnvelope.prototype.channelCountMode = {}
Tone.AmplitudeEnvelope.prototype.channelInterpretation = {}
Tone.AmplitudeEnvelope.prototype.context = {}
Tone.AmplitudeEnvelope.prototype.numberOfInputs = {}
Tone.AmplitudeEnvelope.prototype.numberOfOutputs = {}
Tone.AmplitudeEnvelope.prototype.attack = {}
Tone.AmplitudeEnvelope.prototype.attackCurve = {}
Tone.AmplitudeEnvelope.prototype.decay = {}
Tone.AmplitudeEnvelope.prototype.decayCurve = {}
Tone.AmplitudeEnvelope.prototype.release = {}
Tone.AmplitudeEnvelope.prototype.releaseCurve = {}
Tone.AmplitudeEnvelope.prototype.sustain = {}
Tone.AmplitudeEnvelope.prototype.value = {}
Tone.AmplitudeEnvelope.prototype.dispose = function() {}
Tone.AmplitudeEnvelope.prototype.chain = function() {}
Tone.AmplitudeEnvelope.prototype.disconnect = function() {}
Tone.AmplitudeEnvelope.prototype.fan = function() {}
Tone.AmplitudeEnvelope.prototype.toMaster = function() {}
Tone.AmplitudeEnvelope.prototype.cancel = function() {}
Tone.AmplitudeEnvelope.prototype.getValueAtTime = function() {}
Tone.AmplitudeEnvelope.prototype.triggerAttack = function() {}
Tone.AmplitudeEnvelope.prototype.triggerAttackRelease = function() {}
Tone.AmplitudeEnvelope.prototype.triggerRelease = function() {}

Tone.Volume = function() {}
Tone.Volume.prototype.mute = {}
Tone.Volume.prototype.volume = {}
Tone.Volume.prototype.channelCount = {}
Tone.Volume.prototype.channelCountMode = {}
Tone.Volume.prototype.channelInterpretation = {}
Tone.Volume.prototype.context = {}
Tone.Volume.prototype.numberOfInputs = {}
Tone.Volume.prototype.numberOfOutputs = {}
Tone.Volume.prototype.dispose = function() {}
Tone.Volume.prototype.chain = function() {}
Tone.Volume.prototype.connect = function() {}
Tone.Volume.prototype.disconnect = function() {}
Tone.Volume.prototype.fan = function() {}
Tone.Volume.prototype.toMaster = function() {}

Tone.Panner3D = function() {}
Tone.Panner3D.prototype.coneInnerAngle = {}
Tone.Panner3D.prototype.coneOuterAngle = {}
Tone.Panner3D.prototype.coneOuterGain = {}
Tone.Panner3D.prototype.distanceModel = {}
Tone.Panner3D.prototype.maxDistance = {}
Tone.Panner3D.prototype.orientationX = {}
Tone.Panner3D.prototype.orientationY = {}
Tone.Panner3D.prototype.orientationZ = {}
Tone.Panner3D.prototype.panningModel = {}
Tone.Panner3D.prototype.positionX = {}
Tone.Panner3D.prototype.positionY = {}
Tone.Panner3D.prototype.positionZ = {}
Tone.Panner3D.prototype.refDistance = {}
Tone.Panner3D.prototype.rolloffFactor = {}
Tone.Panner3D.prototype.channelCount = {}
Tone.Panner3D.prototype.channelCountMode = {}
Tone.Panner3D.prototype.channelInterpretation = {}
Tone.Panner3D.prototype.context = {}
Tone.Panner3D.prototype.numberOfInputs = {}
Tone.Panner3D.prototype.numberOfOutputs = {}
Tone.Panner3D.prototype.dispose = function() {}
Tone.Panner3D.prototype.setOrientation = function() {}
Tone.Panner3D.prototype.setPosition = function() {}
Tone.Panner3D.prototype.chain = function() {}
Tone.Panner3D.prototype.connect = function() {}
Tone.Panner3D.prototype.disconnect = function() {}
Tone.Panner3D.prototype.fan = function() {}
Tone.Panner3D.prototype.toMaster = function() {}

Tone.Merge = function() {}
Tone.Merge.prototype.left = {}
Tone.Merge.prototype.right = {}
Tone.Merge.prototype.channelCount = {}
Tone.Merge.prototype.channelCountMode = {}
Tone.Merge.prototype.channelInterpretation = {}
Tone.Merge.prototype.context = {}
Tone.Merge.prototype.numberOfInputs = {}
Tone.Merge.prototype.numberOfOutputs = {}
Tone.Merge.prototype.dispose = function() {}
Tone.Merge.prototype.chain = function() {}
Tone.Merge.prototype.connect = function() {}
Tone.Merge.prototype.disconnect = function() {}
Tone.Merge.prototype.fan = function() {}
Tone.Merge.prototype.toMaster = function() {}

Tone.MidSideMerge = function() {}
Tone.MidSideMerge.prototype._timesTwoLeft = {}
Tone.MidSideMerge.prototype._timesTwoRight = {}
Tone.MidSideMerge.prototype.mid = {}
Tone.MidSideMerge.prototype.side = {}
Tone.MidSideMerge.prototype.channelCount = {}
Tone.MidSideMerge.prototype.channelCountMode = {}
Tone.MidSideMerge.prototype.channelInterpretation = {}
Tone.MidSideMerge.prototype.context = {}
Tone.MidSideMerge.prototype.numberOfInputs = {}
Tone.MidSideMerge.prototype.numberOfOutputs = {}
Tone.MidSideMerge.prototype.dispose = function() {}
Tone.MidSideMerge.prototype.chain = function() {}
Tone.MidSideMerge.prototype.connect = function() {}
Tone.MidSideMerge.prototype.disconnect = function() {}
Tone.MidSideMerge.prototype.fan = function() {}
Tone.MidSideMerge.prototype.toMaster = function() {}

Tone.Filter = function() {}
Tone.Filter.prototype.Q = {}
Tone.Filter.prototype.detune = {}
Tone.Filter.prototype.frequency = {}
Tone.Filter.prototype.gain = {}
Tone.Filter.prototype.rolloff = {}
Tone.Filter.prototype.type = {}
Tone.Filter.prototype.channelCount = {}
Tone.Filter.prototype.channelCountMode = {}
Tone.Filter.prototype.channelInterpretation = {}
Tone.Filter.prototype.context = {}
Tone.Filter.prototype.numberOfInputs = {}
Tone.Filter.prototype.numberOfOutputs = {}
Tone.Filter.prototype.dispose = function() {}
Tone.Filter.prototype.getFrequencyResponse = function() {}
Tone.Filter.prototype.chain = function() {}
Tone.Filter.prototype.connect = function() {}
Tone.Filter.prototype.disconnect = function() {}
Tone.Filter.prototype.fan = function() {}
Tone.Filter.prototype.toMaster = function() {}

Tone.MidSideSplit = function() {}
Tone.MidSideSplit.prototype._midAdd = {}
Tone.MidSideSplit.prototype._sideSubtract = {}
Tone.MidSideSplit.prototype.mid = {}
Tone.MidSideSplit.prototype.side = {}
Tone.MidSideSplit.prototype.channelCount = {}
Tone.MidSideSplit.prototype.channelCountMode = {}
Tone.MidSideSplit.prototype.channelInterpretation = {}
Tone.MidSideSplit.prototype.context = {}
Tone.MidSideSplit.prototype.numberOfInputs = {}
Tone.MidSideSplit.prototype.numberOfOutputs = {}
Tone.MidSideSplit.prototype.dispose = function() {}
Tone.MidSideSplit.prototype.chain = function() {}
Tone.MidSideSplit.prototype.connect = function() {}
Tone.MidSideSplit.prototype.disconnect = function() {}
Tone.MidSideSplit.prototype.fan = function() {}
Tone.MidSideSplit.prototype.toMaster = function() {}

/* CORE */
Tone.Delay = function() {}
Tone.Delay.prototype.delayTime = {}
Tone.Delay.prototype.maxDelay = {}
Tone.Delay.prototype.dispose = function() {}

Tone.AudioNode = function() {}
Tone.AudioNode.prototype.channelCount = {}
Tone.AudioNode.prototype.channelCountMode = {}
Tone.AudioNode.prototype.channelInterpretation = {}
Tone.AudioNode.prototype.context = {}
Tone.AudioNode.prototype.numberOfInputs = {}
Tone.AudioNode.prototype.numberOfOutputs = {}
Tone.AudioNode.prototype.chain = function() {}
Tone.AudioNode.prototype.connect = function() {}
Tone.AudioNode.prototype.disconnect = function() {}
Tone.AudioNode.prototype.dispose = function() {}
Tone.AudioNode.prototype.fan = function() {}
Tone.AudioNode.prototype.toMaster = function() {}

Tone.Emitter = function() {}
Tone.Emitter.mixin = function() {}
Tone.Emitter.prototype.dispose = function() {}
Tone.Emitter.prototype.emit = function() {}
Tone.Emitter.prototype.off = function() {}
Tone.Emitter.prototype.on = function() {}
Tone.Emitter.prototype.once = function() {}

Tone.TimelineState = function() {}
Tone.TimelineState.prototype.length = {}
Tone.TimelineState.prototype.memory = {}
Tone.TimelineState.prototype.getLastState = function() {}
Tone.TimelineState.prototype.getNextState = function() {}
Tone.TimelineState.prototype.getValueAtTime = function() {}
Tone.TimelineState.prototype.setStateAtTime = function() {}
Tone.TimelineState.prototype.add = function() {}
Tone.TimelineState.prototype.cancel = function() {}
Tone.TimelineState.prototype.cancelBefore = function() {}
Tone.TimelineState.prototype.dispose = function() {}
Tone.TimelineState.prototype.forEach = function() {}
Tone.TimelineState.prototype.forEachAfter = function() {}
Tone.TimelineState.prototype.forEachAtTime = function() {}
Tone.TimelineState.prototype.forEachBefore = function() {}
Tone.TimelineState.prototype.forEachBetween = function() {}
Tone.TimelineState.prototype.forEachFrom = function() {}
Tone.TimelineState.prototype.get = function() {}
Tone.TimelineState.prototype.getAfter = function() {}
Tone.TimelineState.prototype.getBefore = function() {}
Tone.TimelineState.prototype.peek = function() {}
Tone.TimelineState.prototype.previousEvent = function() {}
Tone.TimelineState.prototype.remove = function() {}
Tone.TimelineState.prototype.shift = function() {}

Tone.Context = function() {}
Tone.Context.prototype.clockSource = {}
Tone.Context.prototype.isContext = {}
Tone.Context.prototype.latencyHint = {}
Tone.Context.prototype.lookAhead = {}
Tone.Context.prototype.rawContext = {}
Tone.Context.prototype.updateInterval = {}
Tone.Context.prototype.clearTimeout = function() {}
Tone.Context.prototype.close = function() {}
Tone.Context.prototype.createConstantSource = function() {}
Tone.Context.prototype.createStereoPanner = function() {}
Tone.Context.prototype.dispose = function() {}
Tone.Context.prototype.getConstant = function() {}
Tone.Context.prototype.now = function() {}
Tone.Context.prototype.resume = function() {}
Tone.Context.prototype.setTimeout = function() {}
Tone.Context.prototype.emit = function() {}
Tone.Context.prototype.off = function() {}
Tone.Context.prototype.on = function() {}
Tone.Context.prototype.once = function() {}

Tone.TransportEvent = function() {}
Tone.TransportEvent.prototype.Transport = {}
Tone.TransportEvent.prototype.callback = {}
Tone.TransportEvent.prototype.id = {}
Tone.TransportEvent.prototype.time = {}
Tone.TransportEvent.prototype.dispose = function() {}
Tone.TransportEvent.prototype.invoke = function() {}

Tone.Clock = function() {}
Tone.Clock.prototype.callback = {}
Tone.Clock.prototype.frequency = {}
Tone.Clock.prototype.state = {}
Tone.Clock.prototype.dispose = function() {}
Tone.Clock.prototype.getSecondsAtTime = function() {}
Tone.Clock.prototype.getStateAtTime = function() {}
Tone.Clock.prototype.getTicksAtTime = function() {}
Tone.Clock.prototype.nextTickTime = function() {}
Tone.Clock.prototype.pause = function() {}
Tone.Clock.prototype.setTicksAtTime = function() {}
Tone.Clock.prototype.start = function() {}
Tone.Clock.prototype.stop = function() {}
Tone.Clock.prototype.emit = function() {}
Tone.Clock.prototype.off = function() {}
Tone.Clock.prototype.on = function() {}
Tone.Clock.prototype.once = function() {}

Tone.Gain = function() {}
Tone.Gain.prototype.gain = {}
Tone.Gain.prototype.channelCount = {}
Tone.Gain.prototype.channelCountMode = {}
Tone.Gain.prototype.channelInterpretation = {}
Tone.Gain.prototype.context = {}
Tone.Gain.prototype.numberOfInputs = {}
Tone.Gain.prototype.numberOfOutputs = {}
Tone.Gain.prototype.dispose = function() {}
Tone.Gain.prototype.chain = function() {}
Tone.Gain.prototype.connect = function() {}
Tone.Gain.prototype.disconnect = function() {}
Tone.Gain.prototype.fan = function() {}
Tone.Gain.prototype.toMaster = function() {}

Tone.Listener = function() {}
Tone.Listener.prototype.forwardX = {}
Tone.Listener.prototype.forwardY = {}
Tone.Listener.prototype.forwardZ = {}
Tone.Listener.prototype.isListener = {}
Tone.Listener.prototype.positionX = {}
Tone.Listener.prototype.positionY = {}
Tone.Listener.prototype.positionZ = {}
Tone.Listener.prototype.upX = {}
Tone.Listener.prototype.upY = {}
Tone.Listener.prototype.upZ = {}
Tone.Listener.prototype.dispose = function() {}
Tone.Listener.prototype.setOrientation = function() {}
Tone.Listener.prototype.setPosition = function() {}

Tone.Master = function() {}
Tone.Master.prototype.isMaster = {}
Tone.Master.prototype.mute = {}
Tone.Master.prototype.volume = {}
Tone.Master.prototype.chain = function() {}
Tone.Master.prototype.dispose = function() {}

Tone.Buffer = function() {}
Tone.Buffer.cancelDownloads = function() {}
Tone.Buffer.fromArray = function() {}
Tone.Buffer.fromURL = function() {}
Tone.Buffer.load = function() {}
Tone.Buffer.supportsType = function() {}
Tone.Buffer.prototype.duration = {}
Tone.Buffer.prototype.length = {}
Tone.Buffer.prototype.loaded = {}
Tone.Buffer.prototype.numberOfChannels = {}
Tone.Buffer.prototype.reverse = {}
Tone.Buffer.prototype.dispose = function() {}
Tone.Buffer.prototype.fromArray = function() {}
Tone.Buffer.prototype.get = function() {}
Tone.Buffer.prototype.getChannelData = function() {}
Tone.Buffer.prototype.load = function() {}
Tone.Buffer.prototype.set = function() {}
Tone.Buffer.prototype.slice = function() {}
Tone.Buffer.prototype.toArray = function() {}
Tone.Buffer.prototype.toMono = function() {}

Tone.Draw = function() {}
Tone.Draw.prototype.anticipation = {}
Tone.Draw.prototype.expiration = {}
Tone.Draw.prototype.cancel = function() {}
Tone.Draw.prototype.schedule = function() {}

Tone.Buffers = function() {}
Tone.Buffers.prototype.baseURL = {}
Tone.Buffers.prototype.loaded = {}
Tone.Buffers.prototype.add = function() {}
Tone.Buffers.prototype.dispose = function() {}
Tone.Buffers.prototype.get = function() {}
Tone.Buffers.prototype.has = function() {}

Tone.Transport = function() {}
Tone.Transport.prototype.PPQ = {}
Tone.Transport.prototype.bpm = {}
Tone.Transport.prototype.isTransport = {}
Tone.Transport.prototype.loop = {}
Tone.Transport.prototype.loopEnd = {}
Tone.Transport.prototype.loopStart = {}
Tone.Transport.prototype.position = {}
Tone.Transport.prototype.progress = {}
Tone.Transport.prototype.seconds = {}
Tone.Transport.prototype.state = {}
Tone.Transport.prototype.swing = {}
Tone.Transport.prototype.swingSubdivision = {}
Tone.Transport.prototype.ticks = {}
Tone.Transport.prototype.timeSignature = {}
Tone.Transport.prototype.cancel = function() {}
Tone.Transport.prototype.clear = function() {}
Tone.Transport.prototype.getSecondsAtTime = function() {}
Tone.Transport.prototype.getTicksAtTime = function() {}
Tone.Transport.prototype.nextSubdivision = function() {}
Tone.Transport.prototype.pause = function() {}
Tone.Transport.prototype.schedule = function() {}
Tone.Transport.prototype.scheduleOnce = function() {}
Tone.Transport.prototype.scheduleRepeat = function() {}
Tone.Transport.prototype.setLoopPoints = function() {}
Tone.Transport.prototype.start = function() {}
Tone.Transport.prototype.stop = function() {}
Tone.Transport.prototype.syncSignal = function() {}
Tone.Transport.prototype.toggle = function() {}
Tone.Transport.prototype.unsyncSignal = function() {}
Tone.Transport.prototype.emit = function() {}
Tone.Transport.prototype.off = function() {}
Tone.Transport.prototype.on = function() {}
Tone.Transport.prototype.once = function() {}

Tone.OfflineContext = function() {}
Tone.OfflineContext.prototype.clockSource = {}
Tone.OfflineContext.prototype.isContext = {}
Tone.OfflineContext.prototype.latencyHint = {}
Tone.OfflineContext.prototype.lookAhead = {}
Tone.OfflineContext.prototype.rawContext = {}
Tone.OfflineContext.prototype.updateInterval = {}
Tone.OfflineContext.prototype.close = function() {}
Tone.OfflineContext.prototype.createBufferSource = function() {}
Tone.OfflineContext.prototype.now = function() {}
Tone.OfflineContext.prototype.render = function() {}
Tone.OfflineContext.prototype.resume = function() {}
Tone.OfflineContext.prototype.clearTimeout = function() {}
Tone.OfflineContext.prototype.dispose = function() {}
Tone.OfflineContext.prototype.getConstant = function() {}
Tone.OfflineContext.prototype.setTimeout = function() {}
Tone.OfflineContext.prototype.emit = function() {}
Tone.OfflineContext.prototype.off = function() {}
Tone.OfflineContext.prototype.on = function() {}
Tone.OfflineContext.prototype.once = function() {}

Tone.TransportRepeatEvent = function() {}
Tone.TransportRepeatEvent.prototype.Transport = {}
Tone.TransportRepeatEvent.prototype.callback = {}
Tone.TransportRepeatEvent.prototype.id = {}
Tone.TransportRepeatEvent.prototype.time = {}
Tone.TransportRepeatEvent.prototype.dispose = function() {}
Tone.TransportRepeatEvent.prototype.invoke = function() {}

Tone.IntervalTimeline = function() {}
Tone.IntervalTimeline.prototype.length = {}
Tone.IntervalTimeline.prototype.add = function() {}
Tone.IntervalTimeline.prototype.cancel = function() {}
Tone.IntervalTimeline.prototype.dispose = function() {}
Tone.IntervalTimeline.prototype.forEach = function() {}
Tone.IntervalTimeline.prototype.forEachAtTime = function() {}
Tone.IntervalTimeline.prototype.forEachFrom = function() {}
Tone.IntervalTimeline.prototype.get = function() {}
Tone.IntervalTimeline.prototype.remove = function() {}

Tone.Param = function() {}
Tone.Param.prototype.convert = {}
Tone.Param.prototype.units = {}
Tone.Param.prototype.value = {}
Tone.Param.prototype.value = {}
Tone.Param.prototype.value = {}
Tone.Param.prototype.channelCount = {}
Tone.Param.prototype.channelCountMode = {}
Tone.Param.prototype.channelInterpretation = {}
Tone.Param.prototype.context = {}
Tone.Param.prototype.numberOfInputs = {}
Tone.Param.prototype.numberOfOutputs = {}
Tone.Param.prototype._exponentialApproach = function() {}
Tone.Param.prototype._exponentialInterpolate = function() {}
Tone.Param.prototype._linearInterpolate = function() {}
Tone.Param.prototype.cancelAndHoldAtTime = function() {}
Tone.Param.prototype.cancelScheduledValues = function() {}
Tone.Param.prototype.dispose = function() {}
Tone.Param.prototype.exponentialApproachValueAtTime = function() {}
Tone.Param.prototype.exponentialRampTo = function() {}
Tone.Param.prototype.exponentialRampToValueAtTime = function() {}
Tone.Param.prototype.getValueAtTime = function() {}
Tone.Param.prototype.linearRampTo = function() {}
Tone.Param.prototype.linearRampToValueAtTime = function() {}
Tone.Param.prototype.rampTo = function() {}
Tone.Param.prototype.setRampPoint = function() {}
Tone.Param.prototype.setTargetAtTime = function() {}
Tone.Param.prototype.setValueAtTime = function() {}
Tone.Param.prototype.setValueCurveAtTime = function() {}
Tone.Param.prototype.targetRampTo = function() {}
Tone.Param.prototype.chain = function() {}
Tone.Param.prototype.connect = function() {}
Tone.Param.prototype.disconnect = function() {}
Tone.Param.prototype.fan = function() {}
Tone.Param.prototype.toMaster = function() {}

Tone.Timeline = function() {}
Tone.Timeline.prototype.length = {}
Tone.Timeline.prototype.memory = {}
Tone.Timeline.prototype.add = function() {}
Tone.Timeline.prototype.cancel = function() {}
Tone.Timeline.prototype.cancelBefore = function() {}
Tone.Timeline.prototype.dispose = function() {}
Tone.Timeline.prototype.forEach = function() {}
Tone.Timeline.prototype.forEachAfter = function() {}
Tone.Timeline.prototype.forEachAtTime = function() {}
Tone.Timeline.prototype.forEachBefore = function() {}
Tone.Timeline.prototype.forEachBetween = function() {}
Tone.Timeline.prototype.forEachFrom = function() {}
Tone.Timeline.prototype.get = function() {}
Tone.Timeline.prototype.getAfter = function() {}
Tone.Timeline.prototype.getBefore = function() {}
Tone.Timeline.prototype.peek = function() {}
Tone.Timeline.prototype.previousEvent = function() {}
Tone.Timeline.prototype.remove = function() {}
Tone.Timeline.prototype.shift = function() {}

/* SIGNAL */
Tone.Add = function() {}
Tone.Add.prototype.channelCount = {}
Tone.Add.prototype.channelCountMode = {}
Tone.Add.prototype.channelInterpretation = {}
Tone.Add.prototype.context = {}
Tone.Add.prototype.numberOfInputs = {}
Tone.Add.prototype.numberOfOutputs = {}
Tone.Add.prototype.convert = {}
Tone.Add.prototype.units = {}
Tone.Add.prototype.value = {}
Tone.Add.prototype.dispose = function() {}
Tone.Add.prototype.chain = function() {}
Tone.Add.prototype.connect = function() {}
Tone.Add.prototype.disconnect = function() {}
Tone.Add.prototype.fan = function() {}
Tone.Add.prototype.toMaster = function() {}
Tone.Add.prototype.cancelAndHoldAtTime = function() {}
Tone.Add.prototype.cancelScheduledValues = function() {}
Tone.Add.prototype.exponentialApproachValueAtTime = function() {}
Tone.Add.prototype.exponentialRampTo = function() {}
Tone.Add.prototype.exponentialRampToValueAtTime = function() {}
Tone.Add.prototype.linearRampTo = function() {}
Tone.Add.prototype.linearRampToValueAtTime = function() {}
Tone.Add.prototype.rampTo = function() {}
Tone.Add.prototype.setRampPoint = function() {}
Tone.Add.prototype.setTargetAtTime = function() {}
Tone.Add.prototype.setValueAtTime = function() {}
Tone.Add.prototype.setValueCurveAtTime = function() {}
Tone.Add.prototype.targetRampTo = function() {}
Tone.Add.prototype.getValueAtTime = function() {}

Tone.Multiply = function() {}
Tone.Multiply.prototype.channelCount = {}
Tone.Multiply.prototype.channelCountMode = {}
Tone.Multiply.prototype.channelInterpretation = {}
Tone.Multiply.prototype.context = {}
Tone.Multiply.prototype.numberOfInputs = {}
Tone.Multiply.prototype.numberOfOutputs = {}
Tone.Multiply.prototype.convert = {}
Tone.Multiply.prototype.units = {}
Tone.Multiply.prototype.value = {}
Tone.Multiply.prototype.dispose = function() {}
Tone.Multiply.prototype.chain = function() {}
Tone.Multiply.prototype.connect = function() {}
Tone.Multiply.prototype.disconnect = function() {}
Tone.Multiply.prototype.fan = function() {}
Tone.Multiply.prototype.toMaster = function() {}
Tone.Multiply.prototype.cancelAndHoldAtTime = function() {}
Tone.Multiply.prototype.cancelScheduledValues = function() {}
Tone.Multiply.prototype.exponentialApproachValueAtTime = function() {}
Tone.Multiply.prototype.exponentialRampTo = function() {}
Tone.Multiply.prototype.exponentialRampToValueAtTime = function() {}
Tone.Multiply.prototype.linearRampTo = function() {}
Tone.Multiply.prototype.linearRampToValueAtTime = function() {}
Tone.Multiply.prototype.rampTo = function() {}
Tone.Multiply.prototype.setRampPoint = function() {}
Tone.Multiply.prototype.setTargetAtTime = function() {}
Tone.Multiply.prototype.setValueAtTime = function() {}
Tone.Multiply.prototype.setValueCurveAtTime = function() {}
Tone.Multiply.prototype.targetRampTo = function() {}
Tone.Multiply.prototype.getValueAtTime = function() {}

Tone.Scale = function() {}
Tone.Scale.prototype.max = {}
Tone.Scale.prototype.min = {}
Tone.Scale.prototype.dispose = function() {}
Tone.Scale.prototype.connect = function() {}

Tone.Pow = function() {}
Tone.Pow.prototype.value = {}
Tone.Pow.prototype.dispose = function() {}
Tone.Pow.prototype.connect = function() {}

Tone.SignalBase = function() {}
Tone.SignalBase.prototype.connect = function() {}

Tone.EqualPowerGain = function() {}
Tone.EqualPowerGain.prototype.dispose = function() {}
Tone.EqualPowerGain.prototype.connect = function() {}

Tone.TransportTimelineSignal = function() {}
Tone.TransportTimelineSignal.prototype.channelCount = {}
Tone.TransportTimelineSignal.prototype.channelCountMode = {}
Tone.TransportTimelineSignal.prototype.channelInterpretation = {}
Tone.TransportTimelineSignal.prototype.context = {}
Tone.TransportTimelineSignal.prototype.numberOfInputs = {}
Tone.TransportTimelineSignal.prototype.numberOfOutputs = {}
Tone.TransportTimelineSignal.prototype.convert = {}
Tone.TransportTimelineSignal.prototype.units = {}
Tone.TransportTimelineSignal.prototype.value = {}
Tone.TransportTimelineSignal.prototype.cancelAndHoldAtTime = function() {}
Tone.TransportTimelineSignal.prototype.cancelScheduledValues = function() {}
Tone.TransportTimelineSignal.prototype.dispose = function() {}
Tone.TransportTimelineSignal.prototype.exponentialRampToValueAtTime = function() {}
Tone.TransportTimelineSignal.prototype.getValueAtTime = function() {}
Tone.TransportTimelineSignal.prototype.linearRampToValueAtTime = function() {}
Tone.TransportTimelineSignal.prototype.setTargetAtTime = function() {}
Tone.TransportTimelineSignal.prototype.setValueAtTime = function() {}
Tone.TransportTimelineSignal.prototype.setValueCurveAtTime = function() {}
Tone.TransportTimelineSignal.prototype.chain = function() {}
Tone.TransportTimelineSignal.prototype.connect = function() {}
Tone.TransportTimelineSignal.prototype.disconnect = function() {}
Tone.TransportTimelineSignal.prototype.fan = function() {}
Tone.TransportTimelineSignal.prototype.toMaster = function() {}
Tone.TransportTimelineSignal.prototype.exponentialApproachValueAtTime = function() {}
Tone.TransportTimelineSignal.prototype.exponentialRampTo = function() {}
Tone.TransportTimelineSignal.prototype.linearRampTo = function() {}
Tone.TransportTimelineSignal.prototype.rampTo = function() {}
Tone.TransportTimelineSignal.prototype.setRampPoint = function() {}
Tone.TransportTimelineSignal.prototype.targetRampTo = function() {}

Tone.GainToAudio = function() {}
Tone.GainToAudio.prototype.dispose = function() {}
Tone.GainToAudio.prototype.connect = function() {}

Tone.Signal = function() {}
Tone.Signal.prototype.channelCount = {}
Tone.Signal.prototype.channelCountMode = {}
Tone.Signal.prototype.channelInterpretation = {}
Tone.Signal.prototype.context = {}
Tone.Signal.prototype.numberOfInputs = {}
Tone.Signal.prototype.numberOfOutputs = {}
Tone.Signal.prototype.convert = {}
Tone.Signal.prototype.units = {}
Tone.Signal.prototype.value = {}
Tone.Signal.prototype.dispose = function() {}
Tone.Signal.prototype.getValueAtTime = function() {}
Tone.Signal.prototype.chain = function() {}
Tone.Signal.prototype.connect = function() {}
Tone.Signal.prototype.disconnect = function() {}
Tone.Signal.prototype.fan = function() {}
Tone.Signal.prototype.toMaster = function() {}
Tone.Signal.prototype.cancelAndHoldAtTime = function() {}
Tone.Signal.prototype.cancelScheduledValues = function() {}
Tone.Signal.prototype.exponentialApproachValueAtTime = function() {}
Tone.Signal.prototype.exponentialRampTo = function() {}
Tone.Signal.prototype.exponentialRampToValueAtTime = function() {}
Tone.Signal.prototype.linearRampTo = function() {}
Tone.Signal.prototype.linearRampToValueAtTime = function() {}
Tone.Signal.prototype.rampTo = function() {}
Tone.Signal.prototype.setRampPoint = function() {}
Tone.Signal.prototype.setTargetAtTime = function() {}
Tone.Signal.prototype.setValueAtTime = function() {}
Tone.Signal.prototype.setValueCurveAtTime = function() {}
Tone.Signal.prototype.targetRampTo = function() {}

Tone.Subtract = function() {}
Tone.Subtract.prototype.channelCount = {}
Tone.Subtract.prototype.channelCountMode = {}
Tone.Subtract.prototype.channelInterpretation = {}
Tone.Subtract.prototype.context = {}
Tone.Subtract.prototype.numberOfInputs = {}
Tone.Subtract.prototype.numberOfOutputs = {}
Tone.Subtract.prototype.convert = {}
Tone.Subtract.prototype.units = {}
Tone.Subtract.prototype.value = {}
Tone.Subtract.prototype.dispose = function() {}
Tone.Subtract.prototype.chain = function() {}
Tone.Subtract.prototype.connect = function() {}
Tone.Subtract.prototype.disconnect = function() {}
Tone.Subtract.prototype.fan = function() {}
Tone.Subtract.prototype.toMaster = function() {}
Tone.Subtract.prototype.cancelAndHoldAtTime = function() {}
Tone.Subtract.prototype.cancelScheduledValues = function() {}
Tone.Subtract.prototype.exponentialApproachValueAtTime = function() {}
Tone.Subtract.prototype.exponentialRampTo = function() {}
Tone.Subtract.prototype.exponentialRampToValueAtTime = function() {}
Tone.Subtract.prototype.linearRampTo = function() {}
Tone.Subtract.prototype.linearRampToValueAtTime = function() {}
Tone.Subtract.prototype.rampTo = function() {}
Tone.Subtract.prototype.setRampPoint = function() {}
Tone.Subtract.prototype.setTargetAtTime = function() {}
Tone.Subtract.prototype.setValueAtTime = function() {}
Tone.Subtract.prototype.setValueCurveAtTime = function() {}
Tone.Subtract.prototype.targetRampTo = function() {}
Tone.Subtract.prototype.getValueAtTime = function() {}

Tone.Abs = function() {}
Tone.Abs.prototype.dispose = function() {}
Tone.Abs.prototype.connect = function() {}

Tone.Normalize = function() {}
Tone.Normalize.prototype.max = {}
Tone.Normalize.prototype.min = {}
Tone.Normalize.prototype.dispose = function() {}
Tone.Normalize.prototype.connect = function() {}

Tone.ScaleExp = function() {}
Tone.ScaleExp.prototype.exponent = {}
Tone.ScaleExp.prototype.max = {}
Tone.ScaleExp.prototype.min = {}
Tone.ScaleExp.prototype.dispose = function() {}
Tone.ScaleExp.prototype.connect = function() {}

Tone.Zero = function() {}
Tone.Zero.prototype.dispose = function() {}
Tone.Zero.prototype.connect = function() {}

Tone.GreaterThan = function() {}
Tone.GreaterThan.prototype.channelCount = {}
Tone.GreaterThan.prototype.channelCountMode = {}
Tone.GreaterThan.prototype.channelInterpretation = {}
Tone.GreaterThan.prototype.context = {}
Tone.GreaterThan.prototype.numberOfInputs = {}
Tone.GreaterThan.prototype.numberOfOutputs = {}
Tone.GreaterThan.prototype.convert = {}
Tone.GreaterThan.prototype.units = {}
Tone.GreaterThan.prototype.value = {}
Tone.GreaterThan.prototype.dispose = function() {}
Tone.GreaterThan.prototype.chain = function() {}
Tone.GreaterThan.prototype.connect = function() {}
Tone.GreaterThan.prototype.disconnect = function() {}
Tone.GreaterThan.prototype.fan = function() {}
Tone.GreaterThan.prototype.toMaster = function() {}
Tone.GreaterThan.prototype.cancelAndHoldAtTime = function() {}
Tone.GreaterThan.prototype.cancelScheduledValues = function() {}
Tone.GreaterThan.prototype.exponentialApproachValueAtTime = function() {}
Tone.GreaterThan.prototype.exponentialRampTo = function() {}
Tone.GreaterThan.prototype.exponentialRampToValueAtTime = function() {}
Tone.GreaterThan.prototype.linearRampTo = function() {}
Tone.GreaterThan.prototype.linearRampToValueAtTime = function() {}
Tone.GreaterThan.prototype.rampTo = function() {}
Tone.GreaterThan.prototype.setRampPoint = function() {}
Tone.GreaterThan.prototype.setTargetAtTime = function() {}
Tone.GreaterThan.prototype.setValueAtTime = function() {}
Tone.GreaterThan.prototype.setValueCurveAtTime = function() {}
Tone.GreaterThan.prototype.targetRampTo = function() {}
Tone.GreaterThan.prototype.getValueAtTime = function() {}

Tone.AudioToGain = function() {}
Tone.AudioToGain.prototype.dispose = function() {}
Tone.AudioToGain.prototype.connect = function() {}

Tone.WaveShaper = function() {}
Tone.WaveShaper.prototype.curve = {}
Tone.WaveShaper.prototype.oversample = {}
Tone.WaveShaper.prototype.dispose = function() {}
Tone.WaveShaper.prototype.setMap = function() {}
Tone.WaveShaper.prototype.connect = function() {}

Tone.GreaterThanZero = function() {}
Tone.GreaterThanZero.prototype.dispose = function() {}
Tone.GreaterThanZero.prototype.connect = function() {}

Tone.TickSignal = function() {}
Tone.TickSignal.prototype.channelCount = {}
Tone.TickSignal.prototype.channelCountMode = {}
Tone.TickSignal.prototype.channelInterpretation = {}
Tone.TickSignal.prototype.context = {}
Tone.TickSignal.prototype.numberOfInputs = {}
Tone.TickSignal.prototype.numberOfOutputs = {}
Tone.TickSignal.prototype.convert = {}
Tone.TickSignal.prototype.units = {}
Tone.TickSignal.prototype.value = {}
Tone.TickSignal.prototype.exponentialRampToValueAtTime = function() {}
Tone.TickSignal.prototype.getDurationOfTicks = function() {}
Tone.TickSignal.prototype.getTicksAtTime = function() {}
Tone.TickSignal.prototype.getTimeOfTick = function() {}
Tone.TickSignal.prototype.setTargetAtTime = function() {}
Tone.TickSignal.prototype.ticksToTime = function() {}
Tone.TickSignal.prototype.timeToTicks = function() {}
Tone.TickSignal.prototype.chain = function() {}
Tone.TickSignal.prototype.connect = function() {}
Tone.TickSignal.prototype.disconnect = function() {}
Tone.TickSignal.prototype.fan = function() {}
Tone.TickSignal.prototype.toMaster = function() {}
Tone.TickSignal.prototype.cancelAndHoldAtTime = function() {}
Tone.TickSignal.prototype.cancelScheduledValues = function() {}
Tone.TickSignal.prototype.exponentialApproachValueAtTime = function() {}
Tone.TickSignal.prototype.exponentialRampTo = function() {}
Tone.TickSignal.prototype.linearRampTo = function() {}
Tone.TickSignal.prototype.linearRampToValueAtTime = function() {}
Tone.TickSignal.prototype.rampTo = function() {}
Tone.TickSignal.prototype.setRampPoint = function() {}
Tone.TickSignal.prototype.setValueAtTime = function() {}
Tone.TickSignal.prototype.setValueCurveAtTime = function() {}
Tone.TickSignal.prototype.targetRampTo = function() {}
Tone.TickSignal.prototype.dispose = function() {}
Tone.TickSignal.prototype.getValueAtTime = function() {}

Tone.Negate = function() {}
Tone.Negate.prototype.dispose = function() {}
Tone.Negate.prototype.connect = function() {}

Tone.Modulo = function() {}
Tone.Modulo.prototype.value = {}
Tone.Modulo.prototype.dispose = function() {}
Tone.Modulo.prototype.connect = function() {}
